# Version history > Reference: All releases of the OPC UA .NET SDK with new features, changes, and fixes, grouped by version series and minor version. > This content was machine translated and may contain errors. [Read in German](https://www.traeger.de/docs/development/opcua/version-history) The releases are grouped by version series and minor version. The releases of the current version 2.59 are expanded; older releases can be expanded one by one. The [Upgrade to a new version](https://www.traeger.de/en/docs/development/opcua/upgrade) page summarizes which changes affect existing code when you upgrade from an older version. ## 2.50–2.59 (2025–2026) ### 2.59 #### 2.59.0.0 (released on November 9, 2026) **New** - Introduced `OpcObjectTypes.ServerCapabilitiesType` and `OpcObjectTypes.ServerDiagnosticsType`, which identify the object types ServerCapabilitiesType and ServerDiagnosticsType and provide the identifiers of the nodes related to them. Before, the properties of the classes `OpcObjectTypes.OpcServerCapabilitiesType` and `OpcObjectTypes.OpcServerDiagnosticsType` were not reachable, because no instance of them was provided. - Introduced `OpcModifiedNodeHistory`, which keeps the modified values (`OpcModifiedHistoryValue`) of a node, including several modifications of a value at the same timestamp. The values are sorted by their timestamp and, for the same timestamp, from the most recent to the oldest modification. When the capacity is reached, the oldest modification is removed. **Changed** - **Breaking:** Replaced the outdated dependency `Portable.BouncyCastle` (version 1.9.0) with `BouncyCastle.Cryptography` (version 2.7.0), whose assembly is named `BouncyCastle.Cryptography.dll` instead of `BouncyCastle.Crypto.dll`. `CertificateFactoryRandomGenerator` additionally provides `AddSeedMaterial(ReadOnlySpan)` and `NextBytes(Span)`, which the `IRandomGenerator` of `BouncyCastle.Cryptography` declares for .NET 6 and later. Applications that deploy the assemblies themselves must deploy `BouncyCastle.Cryptography.dll` instead of `BouncyCastle.Crypto.dll`. Applications that reference `Portable.BouncyCastle` themselves and use its types must change to `BouncyCastle.Cryptography`, since both packages provide the same types. - Removed the dependency on `System.Management`. - **Breaking:** The operators `<`, `<=`, `>`, `>=`, and `==` of `OpcFilterOperand` throw an `ArgumentNullException` for a left operand that is `null`, and the constructors of `OpcContentFilterElement` throw an `ArgumentNullException` for operands that are `null`. Before, a `NullReferenceException` was thrown. Code that catches the `NullReferenceException` must catch the `ArgumentNullException` instead. - **Breaking:** Removed the class `OpcContentFilterElementFactory`, which had no public members. Code that names the type no longer compiles; an instance of the type could never be obtained. - **Breaking:** `EndpointDescriptionExtensions.SetEndpointPolicy` throws an `ArgumentNullException` for an endpoint policy that is `null`, and the indexer of `OpcSecurityPolicyCollection` throws an `ArgumentNullException` when `null` is set. Before, `SetEndpointPolicy` threw a `NullReferenceException` and the indexer stored an entry without a policy. Code that catches the `NullReferenceException` must catch the `ArgumentNullException` instead, and code that sets `null` using the indexer now fails. - **Breaking:** The `CertificateRequested` event of `OpcServer` and `OpcClient` also occurs when the application certificate exists but is not valid, with the reason `Invalid`, `UseNotAllowed`, `Revoked`, `TimeInvalid`, `IssuerUseNotAllowed`, `IssuerRevoked`, or `IssuerTimeInvalid` (for example `TimeInvalid` for an expired certificate). The certificate is never replaced automatically (`AutoCreateCertificate` of the event data is `false`); unless the handler provides an alternative certificate, it remains in use and a trace entry is written. Before, such a certificate was used without notice. The event now also occurs when a server starts or a client connects with an invalid application certificate, so handlers that handle each reason like a missing certificate are called in this case too. - **Breaking:** Removed `OpcEventContext`, which the SDK never created or returned. Code that references `OpcEventContext` no longer compiles. - **Breaking:** `ExtensionObjectExtensions.To` throws an `ArgumentNullException` instead of a `NullReferenceException` for an extension object that is `null`, and the `Children` of `OpcAddObjectTypeNode` and `OpcAddVariableTypeNode` throw an `ArgumentNullException` instead of a `NullReferenceException` when a command that is `null` is added or set. Code that catches the `NullReferenceException` must catch the `ArgumentNullException` instead. - A custom `IOpcNodeHistoryProvider` should also return the value directly before and the value directly after the requested time range, so that the server can interpolate values when the history is read at specific times or processed. Otherwise such reads still result in `BadNoData`. - **Breaking:** `OpcNodeHistory` uses -1 (unlimited) as its default capacity instead of 0, with which each call to `Add` failed. A capacity of 0 or less than -1 is now rejected with an `ArgumentOutOfRangeException`, also by the constructors of `OpcNodeHistorian`. Code that passes a capacity of 0 (for example `new OpcNodeHistory(0, values)`) now fails with an `ArgumentOutOfRangeException`. - **Breaking:** `OpcNodeHistorian.ModifiedHistory` is an `OpcModifiedNodeHistory` instead of an `OpcNodeHistory`. Code that uses the property as an `OpcNodeHistory` must be changed: `GetValues(DateTime)` replaces the indexer by timestamp, while `RemoveAt(DateTime)`, `Replace`, and the `Replaced` event are no longer available. Code compiled against a previous version must be recompiled. - **Breaking:** Reading (for example with `OpcClient.ReadNodeHistoryModified`) and deleting (for example with `OpcClient.DeleteNodeHistoryModified`) the modified history of an `OpcNodeHistorian` refer to the timestamps of the values instead of the modification times. Several modifications of a value are returned from the most recent to the oldest one, also when reading backward. Code that reads or deletes the modified history using a time range of modification times now receives or deletes other values. - **Breaking:** `OpcClient.BrowseNode(OpcBrowseNode)` and `OpcClient.BrowseNodes` throw an `ArgumentNullException` for a command that is `null`. Before, a `NullReferenceException` was thrown. Code that catches the `NullReferenceException` must catch the `ArgumentNullException` instead. - **Breaking:** `OpcClient.CallFunc` throws an `InvalidCastException` if the first output argument is `null` and the result type is a non-nullable value type. Before, a `NullReferenceException` was thrown. Code that catches the `NullReferenceException` must catch the `InvalidCastException` instead. - **Breaking:** `OpcClient.CallMethods` throws an `ArgumentNullException` for a command that is `null`. Before, such a command was skipped, so that the results of the following commands were returned at the index of the previous command, and a call of commands that are all `null` failed with an `OpcException` stating `BadNothingToDo`. Code that passes a command that is `null` now fails instead of receiving shifted results. - **Breaking:** The single-command overloads `OpcClient.CallMethod(OpcCallMethod)`, `ReadNodeHistory(..., OpcReadNodeHistory)`, `CreateNodeHistory`, `ReplaceNodeHistory`, `UpdateNodeHistory`, `DeleteNodeHistory`, `DeleteNodeHistoryAtTime`, and `DeleteNodeHistoryModified` throw an `ArgumentNullException` with the `ParamName` `command` for a command that is `null`. Before, the `ParamName` stated `commands.Item`, and `CallMethod(OpcCallMethod)` failed with an `OpcException` stating `BadNothingToDo`. Code that catches the `OpcException` of `CallMethod(OpcCallMethod)` for a command that is `null` must catch the `ArgumentNullException` instead. - **Breaking:** The `OpcServer` constructors that take a sequence of nodes throw an `ArgumentNullException` for a node that is `null`. Before, `OpcServer.Start()` failed with an `OpcException`. The exception now occurs when the server is constructed and is an `ArgumentNullException` instead of an `OpcException`. - **Breaking:** `OpcNode.ReadAttributeValueCore` and `OpcNode.WriteAttributeValueCore` throw an `ArgumentNullException` for a value that is `null`. Before, a `NullReferenceException` was thrown. A derived class that catches the `NullReferenceException` must catch the `ArgumentNullException` instead. - **Breaking:** The service requests built from commands (for example `OpcCallMethodsRequest`, `OpcReadNodesRequest`, or `OpcWriteNodesRequest`) throw an `ArgumentNullException` for a command that is `null`. Before, such a command was skipped, so that the results of the following commands were assigned to the wrong command. Code that passes a command that is `null` now fails instead of receiving shifted results. - **Breaking:** `OpcClient.CreateSubscription` throws an `OpcException` stating `BadServerNotConnected` when the client has not been connected or has been disconnected. Before, a `NullReferenceException` was thrown. Code that catches the `NullReferenceException` must catch the `OpcException` instead. - **Breaking:** `OpcEventFilterFactory.Select` throws an `ArgumentNullException` for operands that are `null`. Before, a `NullReferenceException` was thrown while the client was connected. Code that catches the `NullReferenceException` must catch the `ArgumentNullException` instead. - **Breaking:** `OpcEventFilterConstrainedFactory.Where` combines the specified constraint with the constraint of the factory using a logical AND, like a single `Where` with both constraints combined using the `&` operator. Before, the elements of the specified constraint were only appended, so that the root element of the filter was still the first constraint and element operands of the appended constraint referred to wrong elements. An event filter built using chained `Where` calls now restricts the events by all constraints, so that a MonitoredItem may receive fewer events than before. - **Breaking:** `OpcClientApplication.Exit` disconnects the client also in the states `Connecting`, `Reconnecting`, and `Reconnected` (the state the client takes after a reconnect with the same session); while the client connects, `Exit` waits until connecting has completed. In a non-interactive environment, `Exit` also ends `Run` if the client has already been disconnected, for example because reconnecting failed. Before, `Exit` did nothing in these states, so that the client stayed connected or kept reconnecting and `Run` did not return in a non-interactive environment (for example a service did not stop). The events `Exiting` and `Exited` are now raised in the states `Connecting`, `Reconnecting`, and `Reconnected` as well. - **Breaking:** The constructors of `OpcClientApplication`, `OpcServerApplication`, and `OpcServerServiceApplication` check their arguments before the application is registered for the current thread. Before, a constructor that threw an `ArgumentNullException` left the failed instance registered, so that `OpcApplication.Current` returned it and the next constructor on the same thread threw an `InvalidOperationException` until the instance was garbage collected. After a failed construction, `OpcApplication.Current` now returns `null` instead of the failed instance. - An application that has been garbage collected without a call of `Exit` no longer prevents the creation of the next application on the same thread. Before, the next constructor threw an `ArgumentException`. - Applications can be created and exited on several threads at the same time. Before, this could corrupt the registration, so that `OpcApplication.Current` returned the application of another thread or an exception was thrown. - **Breaking:** `OpcServerApplication.Exit` stops the server also in the state `Suspended`. Before, `Exit` did nothing in this state, so that the server stayed suspended and `Run` did not return in a non-interactive environment. The events `Exiting` and `Exited` are now raised in this state as well. - `OpcNodeManager.SyncRoot`, `GetNode(string)`, and `IsNodeReadyToPublish` throw an `InvalidOperationException` when the server using the node manager has not yet been started, like the other members of the node manager that require a started server. Before, a `NullReferenceException` was thrown. - `OpcClient.BrowseNode` and `BrowseNodes` use `OpcBrowseNode.IncludeSubtypes` once it has been set, as the Browse service does. A command without the value set follows the subtypes of its reference types as before. - **Breaking:** The HTTPS endpoints of `OpcServer` let the operating system choose the TLS versions instead of offering TLS 1.0, 1.1, and 1.2. Clients that only support TLS 1.0 or 1.1 can no longer connect over HTTPS where the operating system has disabled these versions. **Fixed** - Issue with the operators `&` and `|` of `OpcContentFilterElement` combining an element with an `OpcContentFilter` created using its constructor (for example `new OpcContentFilter(element1) & element2`), which failed with a `NullReferenceException`. The element is now combined with the existing elements of the filter. - **Breaking:** Issue with `OpcFilterOperand.Between`, which passed the operands in the order lower bound, operand, upper bound, so that, for example, `a.Between(1, 5)` determined whether 1 is between `a` and 5 instead of whether `a` is between 1 and 5. The operands are now passed in the order defined by OPC UA. Code that compensated for the issue by calling `Between` on the lower bound (for example `lower.Between(a, upper)`) now determines whether the lower bound is between `a` and the upper bound and must be changed to `a.Between(lower, upper)`. - Issue with the message of the `NotSupportedException` thrown by the operator `!=` of `OpcFilterOperand`, which suggested the expression `(a < b || a > b)`, which does not compile. The message now suggests `(a < b) | (a > b)`. - Issue with the overload of `OpcHistoryValue.CreateModified` that takes a value, which also set the value in the data of the history value it was called on, while its `Value` property still returned the previous value. The modified value now uses a copy of the data, and the history value remains unchanged. - **Breaking:** Issue with `OpcHistoryValue.Create(OpcValue)`, which created a history value sharing the data of the specified value, so that setting the value of one of them changed the data of the other, while its `Value` property still returned the previous value. The history value now uses a copy of the data. Code that changes an `OpcValue` after passing it to `Create`, or a history value created by `Create`, no longer changes the data of the other value. - Issue with the constructor of `OpcCertificateStoreInfo`, which failed with a `NullReferenceException` for the store type `OpcCertificateStoreType.Application` and a path of a certificate store of the operating system (for example `CurrentUser\My`). - **Breaking:** Issue with `OpcSecurityPolicyCollection.CopyTo`, which copied each policy from the specified array index on to the same index of the array, so that the policies before that index were missing, and which failed with an `ArgumentOutOfRangeException` for an empty array. The method now copies all policies to the array starting at the specified index, like `List.CopyTo`, and throws an `ArgumentException` if the array is too small. Code that passes an array index greater than zero receives all policies starting at that index instead of a part of them at their own index, and code that passes an array that is too small for all policies receives an `ArgumentException`. - **Breaking:** Issue with the `CertificateRequested` event of `OpcServer` and `OpcClient`, where a certificate provided using `AlternativeCertificate` of the event data was not used: a server without an application certificate failed to start ("Server does not have an instance certificate assigned"), and otherwise the certificate of the application store remained in use. The provided certificate is now used, also on later starts and connects; it must contain its private key. Handlers that set `AlternativeCertificate` to another certificate now change the certificate the application uses. - **Breaking:** Issue with `OpcStruct`, where creating the data type of a structure with an array field whose data type is unknown failed with a `NullReferenceException`. An `InvalidOperationException` that names the data type, the field, and the structure is now thrown. Code that catches the `NullReferenceException` in this case does not catch the `InvalidOperationException`. - **Breaking:** Issue with `OpcEnum`, where fields defined without a value got the value 0 if another field was defined with a value other than 0, and where the specified `OpcEnumField` instances were changed. Like in C#, a field defined without a value now follows the value of the field before it (`A, B, C = 5, D` results in 0, 1, 5, 6), and the specified instances remain unchanged. Enumerations with fields defined without a value next to fields defined with a value, and enumerations whose fields are all defined with the value 0, get other values; the `Value` of an `OpcEnumField` specified without a value remains 0, and `GetFields` returns copies. - Issue with `EnumStrings` of `OpcMultiStateDiscreteNode`, where reading the property of a node whose EnumStrings variable has no value threw an `ArgumentNullException`. The property now provides `null` in this case. The issue existed since version 2.53.0.0. - Issue with `AvailableStates` and `AvailableTransitions` of `OpcFiniteStateMachineNode`, where reading the property of a state machine without the optional AvailableStates or AvailableTransitions variable, or without its value, threw an `ArgumentNullException`. The property now provides `null` in this case. The issue existed since version 2.54.0.0. - Issue with `OpcFiniteStateMachineNode`, where a state machine whose states are identified by a type that is not an enumeration (for example `uint`) ended in a `StackOverflowException` when the sub-state machine of a state was created. The state number is now converted to `T` and passed to `CreateSubStatesMachineNode(T)`. The issue existed since version 2.54.1.0. - Issue with the members a node type inherits from its base type (for example returned by `OpcNodeTypeInfo.GetMembers` of a subtype), where reading `Parent` of an inherited variable or object member ended in a `StackOverflowException` that terminated the application. `Parent` now provides the parent of the member declared by the base type. The issue existed since version 2.50.4.0. - Issue with the constructor of `OpcClassicInterface`, where an interface specification without a name and without a version failed with a `NullReferenceException`. The version 1.0 and a name made of the category and that version are now used in this case. The issue existed since version 2.6.0.0. - Issue with `OpcMethodNode.Call`, where each entry of a non-empty `outputArguments` list was added to the list a second time before the output arguments of the method. The method now adds only its output arguments to the list. The issue existed since version 2.33.0.0. - **Breaking:** Issue with `OpcServer`, where a request of the services AddNodes, AddReferences, DeleteNodes, DeleteReferences, or Call that contained a command with a null identifier was rejected as a whole (`BadNothingToDo`, for AddNodes, DeleteNodes, and DeleteReferences `BadUnexpectedError`). The other commands are now executed, and the command with the null identifier has the status defined by OPC UA (`BadParentNodeIdInvalid`, `BadNodeIdInvalid`, `BadSourceNodeIdInvalid`, `BadTargetNodeIdInvalid`, `BadReferenceTypeIdInvalid`, or `BadMethodInvalid`). The issue existed since version 2.7.0.0, for Call since version 2.50.5.0. Such a request is no longer rejected, so that `RequestValidating` is raised with a good result, the request is processed, and it is not counted in `RejectedRequestsCount` of the server diagnostics. Server applications that relied on the rejection must handle commands with a null identifier themselves. - Issue with the AddNodes service of `OpcServer`, where a node of the node class `Unspecified` was not rejected as an invalid node class. The server now reports `BadNodeClassInvalid` for such a node, as defined by OPC UA. The issue existed since version 2.7.0.0. - Issue with the AddNodes service of `OpcServer`, where a node the server could not create was reported as added with the status `Good` and without a node identifier. The server now reports `BadNotSupported` for such a node. The issue existed since version 2.7.0.0. - Issue with `OpcNodeHistory.Enumerate(DateTime?)` and `Enumerate(DateTime?, DateTime?)`, which returned values outside of the time range if a bound was not the timestamp of a value, for example all values before the start time or after the end time. The methods now return the values within the time range, including its bounds. - Issue with `OpcNodeHistory.RemoveRange(DateTime?)` and `RemoveRange(DateTime?, DateTime?)`, which removed no value if a bound was `null`, `DateTime.MinValue`, or `DateTime.MaxValue`, so that `RemoveRange(DateTime?)` never removed a value. Such a bound now does not limit the time range. As a result, an `OpcNodeHistorian` no longer reports values as deleted without deleting them when a client deletes the history of a node without a start or end time. - Issue with reading the history of a node at specific times (for example with `OpcClient.ReadNodeHistoryAtTime`) or processed (for example with `OpcClient.ReadNodeHistoryProcessed`) from an `OpcServer`, where a time between two values resulted in `BadNoData` instead of an interpolated value. `OpcNodeHistorian.ReadHistory` now also provides the value directly before and the value directly after the time range, from which the server determines the value at or before a requested time. Reading the raw history with `ReturnBounds` now returns the bounding values instead of `BadBoundNotFound`. - Issue with the history services of `OpcNodeHistorian` for a node with the ValueRank `Any`, `ScalarOrOneDimension`, or `OneOrMoreDimensions`, which rejected each value with `BadTypeMismatch`. A value is now accepted if its value rank is valid for the value rank of the node. - Issue with `OpcNodeHistorian`, which set `PercentDataBad` and `PercentDataGood` of the AggregateConfiguration of the node to 0 or 100 only. The percentages are now calculated from the numbers of bad and good values. - Issue with `OpcSubscriptionDiagnostics.RepublishMessageRequestCount`, which the server increased twice per republish request. - Issue with `OpcReadNodeHistoryDetails.ReturnBounds` (for example of `OpcReadNodeHistoryRawDetails`), whose setter set the value `true` regardless of the value passed, so that the bounding values could not be turned off again once requested. - Issue with the constructor of `OpcNodeHistorian`, which added `HistoryReadOrWrite` to the `AccessLevel` and `UserAccessLevel` of the node and set its `IsHistorizing` before rejecting an invalid capacity with an `ArgumentOutOfRangeException`. The arguments are now checked before the node is changed, and for an invalid `modifiedCapacity` the exception names the parameter `modifiedCapacity` instead of `capacity`. - Issue with deleting the raw or modified history of a node within a time range (for example with `OpcClient.DeleteNodeHistory` or `OpcClient.DeleteNodeHistoryModified` with a start or end time) from an `OpcServer`, which deleted the whole history of the node instead. The issue existed since version 2.7.0.0. - Issue with inserting or replacing the history of a node (for example with `OpcClient.CreateNodeHistory` or `OpcClient.ReplaceNodeHistory`) in an `OpcServer`, which processed each insert or replace as an update. Inserting a value at the timestamp of an existing value replaced it instead of resulting in `BadEntryExists`, and replacing a value at a timestamp without a value inserted it instead of resulting in `BadNoEntryExists`. The issue existed since version 2.7.0.0. - Issue with `OpcUpdateNodeHistoryDataDetails` and `OpcUpdateNodeHistoryStructureDataDetails` of a request received by an `OpcServer` (for example in the `RequestValidating` event), whose `Values` were `null`. - Issue with the history services of `OpcNodeHistorian` (`CreateHistory`, `UpdateHistory`, `ReplaceHistory`, and `DeleteHistory`), which failed with an `ArgumentException` from the second value of a call on, because the modified history kept one value per modification time. A client received `BadUnexpectedError` for the node, while the values before had already been changed. Each modification is now kept. - Issue with `OpcServer.RegisterNamespace(Uri)`, which registered a URI that is not a valid namespace in the namespace table before rejecting it with a `FormatException`. - `NullReferenceException` in `OpcClientIdentity.Matches` for an identity that has been created with a password that is `null`. Such an identity now matches no password. - Issue with `OpcAccessControlEntry.EndpointAccessMode`, which returned the `OperationAccessMode` of the entry instead of the access mode of the endpoints. The access control itself was not affected: whether an endpoint is enabled or disabled for a principal was already evaluated using the access mode of the endpoints. - Issue with `OpcServerDiagnostics.IsEnabled`, which threw an `ArgumentOutOfRangeException` when the diagnostics were disabled while the server was running and held the diagnostics of at least one subscription. - Issue with `OpcDataTypeSystem.Default` and `OpcNodeTypeSystem.Default` (for example `GetTypes`), which failed with a `FileNotFoundException`, because the predefined nodes of OPC UA (resource `Opc.Ua.PredefinedNodes.uanodes`) were not embedded in the assembly. The resource is now embedded, and its data type nodes, which also state the DataTypeDefinition attribute, are read correctly. (`Opc.UaFx.Client` only) - Issue with `EnumValues` of `OpcMultiStateValueDiscreteNode` and `Value` of `OpcEnumValuesPropertyNode`, which threw an `ArgumentNullException` when the EnumValues variable had no value, so that a server with such a node failed to start. Both return `null` in this case now. - Issue with `OpcFiniteStateMachineNode`, which failed with a `NullReferenceException` when its type declared a sub-state machine for a state without the class creating a node for it (see `CreateSubStatesMachineNode`), so that a server with such a state machine failed to start. ### 2.58 > **2.58.0.0 (released on October 30, 2026)** > > **New** > - Introduced `OpcCertificateSettings.Organization`, which adds the organization (O) to the subject of the application instance certificate the SDK creates, as required by OPC UA. For an `OpcServer`, it is taken from `OpcServerInfo.CompanyName`. Without a known organization, the subject remains as before. > - Introduced `OpcRequestProcessedEventArgs.RequestType` and `IsUnsupportedService`, and the members `RegisterServer`, `RegisterServer2`, and `FindServersOnNetwork` of `OpcRequestType`, so that a server can tell which service a request called, including services it does not support. > - Introduced the `SessionActivationFailed` event of `OpcServer`, which occurs for each rejected session activation and states the identity the client used (`OpcUserNameIdentityTokenInfo`, `OpcCertificateIdentityTokenInfo`) without its password or token data. > - Introduced `OpcServerDiagnostics.IsEnabled` to turn on the diagnostics of sessions and subscriptions (default `false`). > - Introduced `OpcServer.Discovery` with `OpcServerDiscovery.RegistrationInterval`, the interval of the registration at the local discovery server (default 30000 ms; 0 disables the registration). > - Introduced overloads of `OpcDiscoveryClient.DiscoverEndpoints` and `DiscoverServers` that filter by transport profile and server URI. > - `OpcBrowseNode.IncludeSubtypes` is now public (default `false`), and `OpcViewDescription` provides public constructors to browse a view. In this version, `IncludeSubtypes` only takes effect through `client.Services.Browse`; `BrowseNode` and `BrowseNodes` do not evaluate the property yet. > - Introduced `OpcClient.ChangeUserIdentity` to change the user identity of a connected session. > - Introduced `OpcClient.ReconnectInterval`, the time between two reconnect attempts (formerly `ReconnectTimeout`, which remains as a hidden alias), and `OpcClient.MaxReconnectDuration`, which ends the reconnect attempts after the specified time (default 0, unlimited). > - Introduced `OpcDataFieldInfo.GetLength`, which states the maximum length of each dimension of a field. > - **Breaking:** Introduced `OpcRawObject`, which represents a value of a structure the SDK cannot decode (an unknown data type or a field without a fixed ValueRank) with its encoding and encoded body, and `OpcData.Encode` to encode a structure as an `OpcRawObject`. Code that expected an array of bytes or an `XmlElement` for a value of an unknown structure now receives an `OpcRawObject`; its `RawData` holds what was returned before. > - **Breaking:** Introduced the attributes `RolePermissions`, `UserRolePermissions`, `AccessRestrictions`, and `AccessLevelEx` in `OpcAttribute` and `OpcAttributes`, the member `DataTypeDefinition` of `OpcAttributes`, and the types `OpcRolePermission` and `OpcPermissions`. Reading the DataTypeDefinition attribute now yields an `OpcDataTypeInfo` instead of a `StructureDefinition` or `EnumDefinition` of the stack, and reading RolePermissions or UserRolePermissions yields an array of `OpcRolePermission` instead of `RolePermissionType`. > - Introduced `OpcServerSecurity.IsAuditingEnabled` (default `false`) and the audit events of the secure channel services (AuditOpenSecureChannelEventType, AuditChannelEventType). > - The trace event of the stack (`Opc.Ua.Tracing.Instance.TraceEventHandler`) provides the traced exception in `TraceEventArgs.Exception`. > > **Changed** > - **Breaking:** Removed the `CertificateFactory` of the stack from the public API of the package, since the SDK does not provide CA signing or CRL generation. Code that uses `CertificateFactory` no longer compiles. > - **Breaking:** `OpcSecurityAlgorithm.Auto` and the default endpoints of the discovery server and of the OPC Classic wrapper server use `Basic256Sha256` instead of the deprecated `Basic256` (`Sign`) and `Basic128Rsa15` (`SignAndEncrypt`). A client using `Auto` no longer connects to a server that offers only the deprecated policies. > - The certificate the SDK creates for an `OpcServer` also names the fully qualified name of the machine, so that clients that connect by that name accept it. An existing certificate remains unchanged. > - **Breaking:** `OpcServer` reports audit events only while `OpcServerSecurity.IsAuditingEnabled` is `true`, and only to clients connected over `SignAndEncrypt` or HTTPS with a user in the SecurityAdmin role, as defined by OPC UA. A server reports session audit events only after `IsAuditingEnabled` has been set to `true`. > - **Breaking:** `State`, `StateChanged`, and `BreakDetected` of `OpcClient` follow a lost connection detected by a failing service call (for example `BadConnectionClosed` or `BadSessionIdInvalid`) at once instead of with the next keep-alive, and a recreated session reconnects to a restarted server within one interval. Code that relied on the state changing only with the keep-alive now sees the change earlier. > - **Breaking:** The data type system of OPC UA provides all predefined data types (for example `Integer`, `UInteger`, `Enumeration`, or `Image`), each data type states its supertype as `BaseType`, and fields of data types derived from a built-in type (for example `Duration`, `UtcTime`, or `LocaleId`) are decoded. Built-in types and the structures of OPC UA now state their supertype as `BaseType` instead of none, and a field of a type derived from `ByteString` yields a `ByteString` instead of an array of bytes. > - `OpcServer` no longer traces a connection reset by a client as an error, neither during a read nor when it closes the socket. > - **Breaking:** `OpcClient.ReconnectTimeout` and `DefaultReconnectTimeout` are obsolete; use `ReconnectInterval` and `DefaultReconnectInterval` instead. Code that uses them receives a compiler warning, and a compiler error with `TreatWarningsAsErrors`. > - **Breaking:** The single-node history services `OpcClient.ReadNodeHistoryProcessed`, `ReadNodeHistoryAtTime`, and `ReadNodeHistoryModified` throw an `OpcException` with the status code of the server (for example `BadAggregateNotSupported`) for a node the server rejected, and return an empty result for a node the server accepted without values. Before, a `KeyNotFoundException` was thrown in both cases. Code that catches the `KeyNotFoundException` must catch the `OpcException` instead. > - **Breaking:** `OpcDiscoveryClient` (`DiscoverEndpoints`, `DiscoverServers`, and its constructors) throws an `OpcException` stating the reason (for example `BadSecureChannelClosed`) when the server cannot be reached, closes the channel during the handshake, or the discovery URL uses an unsupported scheme. The history navigators of `OpcClient.ReadNodeHistory` and `ReadEventHistory` throw an `OpcException` stating `BadCommunicationError` when a page was not finished within the maximum number of requests. Before, the `ServiceResultException` of the stack was thrown. Code that catches the `ServiceResultException` must catch the `OpcException` instead. > - **Breaking:** `OpcViewDescription.Default` is now a `static readonly` field, so that the default view cannot be replaced. Code that assigns `OpcViewDescription.Default` no longer compiles. Code compiled against an older version that reads `OpcViewDescription.Default` must be recompiled, because the property has become a field. > > **Fixed** > - Issue with methods in `OpcServer` that are implemented by a command (for example a method of an imported NodeSet implemented using `OpcNodeSetManager.ImplementNodeCallback`) and declare an argument with the ValueRank `Any`, `ScalarOrOneDimension`, or `OneOrMoreDimensions`. Each call of such a method failed with an `IndexOutOfRangeException`. The value of such an argument is now passed to the command as a scalar or an array according to the value received, for example an array of ByteStrings as `ByteString[]`, as with an argument declared as a one-dimensional array. > - Issue with nodes created with the model of their type (for example instances of companion specifications), whose variables did not take the access levels and write masks of the NodeSet and could be written regardless. The issue existed since version 2.50.6.0. > - Issue with notifiers added using `OpcNodeManager.AddNotifierNode`, which a client browsing the notifier hierarchy from the Server object did not find. > - Issue with arrays of `object` (for example a method argument of the data type BaseDataType and the ValueRank `OneDimension`), which were encoded as an array of structures instead of an array of variants. > - Issue with `OpcServer`, which offered an endpoint several times when an endpoint policy was configured more than once. The server keeps the first policy and removes the repeated ones when it starts. > - Issue with `OpcServer`, which traced the error "Could not load CertificateTrustList for UserTokenPolicy" on every start. > - **Breaking:** Issue with `OpcServer`, where a start changed the `ServerConfiguration` of the application, so that a restart offered anonymous access although only the `OpcUserNameAcl` was enabled. The server now works with a copy of the configuration. Code that reads `Configuration.ServerConfiguration` after the start sees the values it set itself instead of the policies in use. > - Issue with `OpcClient.Connect`, which failed with an `IndexOutOfRangeException` on a server whose data type dictionaries state a NamespaceUri not at all or several times. A dictionary that cannot be loaded is left out and traced. The issue existed since version 2.8.0.0. > - Issue with `OpcNodeManager`, which raised `MonitoredItemsDeleted` instead of `MonitoredItemsModified` when a MonitoredItem was modified. The issue existed since version 2.7.4.0. > - Issue with `OpcClient`, which failed to connect to a server offering a user token policy with an unsupported security policy (for example `RSA_DH_AesGcm`) before a supported one. > - Issue with `OpcServer`, which terminated with a `StackOverflowException` when diagnostics were enabled, a client monitored the session or subscription diagnostics, and another session called a session service. > - **Breaking:** Issue with reading processed history (for example `OpcClient.ReadNodeHistoryProcessed`), which requested both timestamps, so that a server could reject the request with `BadTimestampsToReturnInvalid`. The issue existed since version 1.5.11.0. The processed values no longer carry a server timestamp. > - Issue with `OpcServer`, where a request to read the modified history arrived as `OpcReadNodeHistoryRawDetails` instead of `OpcReadNodeHistoryModifiedDetails`. The issue existed since version 2.7.0.0. > - Issue with multi-dimensional fields of a structure (for example `UInt16[2,3,2]`), which were left out of its encoding. The issue existed since version 2.8.0.0. > - Issue with an `OpcStatusCode`, which could not be passed as a method argument or written as a value. > - Issue with `OpcClient`, which remained in the `Reconnecting` state when the server rejected one of its subscriptions after a reconnect. The issue existed since version 2.32.0.0. > - **Breaking:** Issue with a structure described in a data type dictionary whose field refers to a data type known by its DataTypeDefinition only, which the client could not resolve. The issue existed since version 2.40.0.0. The `Name` and `XmlName` of such a data type now state the namespace of its node instead of the namespace of OPC UA. > - Issue with fields declared with a data type that has no definition of its own (for example a vendor's subtype of `Byte`), which stated the nearest supertype instead of their declared data type, and with `OpcClient.GetDataType`, which provided no data type for such a data type. > - Issue with a variable node of an array type created without a value (for example `new OpcDataVariableNode(name)`), which stated a scalar ValueRank and no array dimensions. The issue existed since version 2.52.0.0. > - Issue with a matrix of structures, which failed to encode with an `InvalidCastException`. The issue existed since version 2.9.2.0. > - Issue with the retain policies of conditions, which did not retain a condition for every state they name, so that, for example, an active alarm was no longer retained once it had been acknowledged. The issue existed since version 2.55.0.0. > - Issue with the GDS Push Management of `OpcServer`: CreateSigningRequest rejected a subject name passed by the client and requested neither the organization nor the application URI of the certificate, UpdateCertificate refused a certificate whose subject differed from the current one in more than the common name, and ApplyChanges left the server without the new certificate or without its private key, so that connections using `Sign` or `SignAndEncrypt` failed. The issue existed since version 2.53.0.0. > - Issue with the GDS Push Management of `OpcServer`, which stated no supported private key formats unless formats were configured (now PFX and PEM), and refused CreateSigningRequest and UpdateCertificate without a certificate type for a certificate group of a single type. The issue existed since version 2.53.0.0. > - `KeyNotFoundException` in the single-node history update services `OpcClient.CreateNodeHistory`, `ReplaceNodeHistory`, `UpdateNodeHistory`, `DeleteNodeHistory`, `DeleteNodeHistoryAtTime`, and `DeleteNodeHistoryModified` for a NodeId stating a namespace index only (for example `ns=2;s=Value`). The results of the history update services are now keyed by the NodeId of the command. > - Endless history read when the server rejects a node on a subsequent page, because the continuation point of the rejected node was requested again on each page. The issue existed since version 1.6.5.0. > - Issue with a new subscription whose MonitoredItems the server rejected. If the subsequent deletion of the subscription failed too, its error replaced the one of the MonitoredItems. The `OpcException` now states the reason why the MonitoredItems were rejected. The issue existed since version 2.32.0.0. > - Exception on Linux with newer OpenSSL versions when creating an application certificate. ### 2.57 > **2.57.1.0 (released on October 23, 2026)** > > **New** > - Introduced the `NotificationFailed` event in `OpcSubscription` and `OpcClient`, and the corresponding handler `OpcSubscriptionSetup.NotificationFailed`, which occurs when a notification message from the server failed to be received, for example because a value in it cannot be decoded. Before, the data changes and events of such a message were dropped without notice. The event is first raised by the `OpcSubscription` the message belongs to and, if not handled, by the `OpcClient`. A message whose subscription is not known (yet) is reported by the `OpcClient` only. > - Introduced `OpcAttribute.DataTypeDefinition` to read the DataTypeDefinition attribute of a data type node. > > **Fixed** > - Issue with structured data types known only by their DataTypeDefinition (for example when using `OpcClient.UseDynamic`) that declare a member of another structured data type. Since version 2.57.0, such a member was decoded without its fields, so that the values decoded after it could be wrong, events holding such a structure were dropped without notice, or decoding failed with an exceeded `MaxStringLength` or the status code `BadEncodingLimitsExceeded`. > - Issue with structured data types known only by their DataTypeDefinition that declare a member of a simple data type without a definition of its own (for example a vendor-specific subtype of `Byte`, `UInt16`, or `String`). Decoding such a structure failed with an `ArgumentNullException` and the whole read with the status code `BadUnknownResponse`. Such a member is now decoded as the nearest supertype the client knows. > - Deadlock between Browse requests and node manager changes made while holding the node manager lock. > - Issue with events of a built-in event type in `OpcClient`. Since version 2.56.0, such an event was created as an instance of one of the base types of its event type, for example a dialog condition as `OpcCondition` instead of `OpcDialogCondition` or an alarm condition as `OpcAcknowledgeableCondition` instead of `OpcAlarmCondition`. > - Issue that caused `OpcClient.Connect()` to fail when `UseDynamic` is enabled and the server sends the same HasSubtype or HasEncoding reference of a data type more than once. > - `NullReferenceException` in `OpcClient` with servers that return an endpoint without a URL. > **2.57.0.0 (released on September 14, 2026)** > > **Fixed** > - Issue with structured data types using `OpcEncodingMaskKind.Auto` whose first optional member is not set. Values decoded after such a member could be wrong, or decoding failed with an `EndOfStreamException` or a `ServiceResultException` reporting an exceeded `MaxStringLength`. > - Issue with members of a structured data type declared as one of the wrapper types `OpcText`, `OpcName`, `OpcNodeId`, `OpcValue` or `OpcEngineeringUnitInfo`. Such a member is now encoded and decoded consistently, whether it holds a value or a null reference. > - Issue with members of a structured data type declared as a nullable value type (for example `int?`, `short?`, `double?` or `DateTime?`). The value of such a member is now preserved. > - `NullReferenceException` while decoding a structured data type with an array member which is not optional and holds a null reference. > - `InvalidCastException` while decoding an array of `Guid` values. > - Issue with empty arrays of the wrapper types `OpcText`, `OpcName`, `OpcValue` and `OpcEngineeringUnitInfo`. As a member of a structured data type such an array is now encoded as an empty array instead of a null reference, and as a parameter of a method call it is now passed as an array of the type the called method declares, which a server accepts. Before, only a null reference was accepted for such a parameter. > - Issue with an empty array of `OpcNodeId` values being passed as an array of expanded node identifiers. ### 2.56 > **2.56.0.0 (released on August 19, 2026)** > > **Fixed** > - Ensured that the `RetainState` is not automatically updated by any sub-state different than the `EnableState` if the `RetainPolicy` is `Manual`. > - Incorrectly handled `nodeChanges` in `OpcNode.UpdateChanges`: The specified parameter was not passed to the handlers used and was therefore omitted. Only the already pending changes were forwarded to the handlers used for data change notifications. > - Issue with wrong event type resolution in `OpcClient` if an event type is registered using only an expanded node identifier (for example using `OpcNamespace.GetId`, where the `OpcNamespace` instance does not have a namespace index assigned). This results in always receiving `OpcEvent` instances instead of the specific sub-type of `OpcEvent` or a custom typed event data storage. ### 2.55 > **2.55.0.0 (released on August 7, 2026)** > > **New** > - Introduced new `OpcConditionNode.IsRetainedPolicy` property in `OpcConditionNode` to override the default logic used to control the value of the `OpcConditionNode.IsRetained` property according to the different states defined by condition nodes (for example `EnableState`, `ActiveState`, `AckedState`, `ConfirmState`). The default value used for this property depends on the subtype of the `OpcConditionNode` used. This way you can gain full control of the `IsRetained` property using the value `OpcConditionRetainPolicy.Manual` for the `IsRetainedPolicy` property. > > **Changed** > - The initial value of the `OpcConditionNode.IsRetained` property and its subtypes (`OpcAcknowledgeableConditionNode` and `OpcAlarmConditionNode`) including the traversal subtypes might be different starting with this version. This ensures the correct initial value according to the condition type's specific state machine. To understand the different conditions see OPC UA Part 9. In addition the documentation of the new `OpcConditionRetainPolicy` enumeration provides additional details. However the specific condition type uses by default the corresponding policy to provide compliant initial values. To override that you can use the value `OpcConditionRetainPolicy.Manual` for the `OpcConditionNode.IsRetainedPolicy` property to gain full control of the `IsRetained` property. > > **Fixed** > - `StackOverflowException` when the machine is under load. ### 2.54 > **2.54.1.1 (released on July 27, 2026)** > > **Fixed** > - `StackOverflowException` in the new `OpcFiniteStateMachineNode` class when using `ChangeStateTo`. > **2.54.1.0 (released on July 22, 2026)** > > **New** > - Added support for dynamic data types which use recursive references to themselves. > - Introduced new protected virtual property `InheritReferenceTypeId` for `OpcInstanceNodes` to control whether the `DefaultReferenceTypeId` is to be inherited by its direct children. > - Introduced new `OpcNodeSet.GetNodes` method to retrieve the whole address space defined by a NodeSet. > > **Fixed** > - Issue with incorrectly generated DataTypeDefinition attribute in the `OpcServer` when using structured data types with optional fields using `OpcEncodingMaskKind.Explicit`. > - Issue with incorrect encoding of optional fields in the `OpcClient` when enabling `UseDynamic` and the server doesn't provide a `TypeDictionary`. > - Issue with only root node based node retrieval using the method `OpcNodeSet.GetNode`. The method now retrieves any node in the NodeSet loaded. > - Issue with node retrieval using the method `OpcNodeSet.GetNode` after loading a NodeSet without a custom context with matching namespace URIs. > **2.54.0.0 (released on June 25, 2026)** > > **New** > - Added new `SupportedTokenTypes` property to `OpcEndpointDescription` to provide an enumerable sequence of supported `OpcAccessControlTokenType` values to identify the supported access control list using the endpoint provided by the server. This can be discovered using `OpcDiscoveryClient.DiscoverEndpoints(...)`. > - Added new properties `AvailableStates` and `AvailableTransitions` to `OpcFiniteStateMachineNode`. > - Added new property `SupportCurrentState` to support implementation of state machines which do not support the mandatory CurrentState node using a custom override of the property to disable the CurrentState support including calls to the method `ChangeStateTo`. In addition the CurrentState node delivers `Bad` as status code and `BAD` as value, while its child node "Id" provides a null reference as value. > - Added support for providing event history in the `OpcServer` using the `IOpcEventHistoryProvider` interface, and for reading event history in the `OpcClient` using the `ReadEventHistory` method. > - Added property `OpcServerBinding.UseExclusiveAddress` that specifies whether only one process is allowed to bind to the port. > > **Changed** > - Enhanced certificate validation especially for application instance certificates to support compliant validation of basic constraint extensions. This is required for CTT compliance. > - By default, the listener socket now uses an exclusive address when binding to the port. This behavior can be controlled with the new `OpcServerBinding.UseExclusiveAddress` property. > > **Fixed** > - Issue with undefined array dimensions in NodeSet files of variable nodes and structured data type definitions, which define a ValueRank greater than the value of zero. The ArrayDimensions attribute is now initialized with an empty array dimensions array using the value of the ValueRank attribute. > - `ArgumentNullException` occurred in the `OpcServer` when a client calls ConditionRefresh. Note: A side effect of this fix is that when a client calls ConditionRefresh, the SDK may now automatically send event data even if the application doesn't implement the `QueryEventsCallback`. > - Issue with missing structured data types in `OpcNodeSet` after importing a `NodeSet2.xml` file which defines several data types using only `DataTypeDefinitions` and partially using (additional) `DataTypeDescriptions` which are not referenced by `DataTypeEncodings` which themselves do not use inverse references back to their encoded DataType node. Please note that in such cases the API ignores any `DataTypeDescription` and will provide the DataType related information using the DataTypeDefinition of the DataType node. > - `NullReferenceException` occurred while calling `OpcServer.GetDataTypes()` when a NodeSet has been loaded that contains an empty structure definition. > - `NullReferenceException` occurred when importing NodeSets that use a string as namespace URI which cannot be parsed as URI. > - `OpcPropertyNode` was not visible in the address space when type parameter `T` was a wrapper type like `OpcText`, and when using a constructor that takes a parent node. > - `OpcText.Equals()` and `.CompareTo()` methods could throw a `NullReferenceException` and could return a wrong comparison result. > - The `OpcServer` could return too many history values when the size was limited. ### 2.53 > **2.53.1.0 (released on May 6, 2026)** > > **Fixed** > - Exception occurred when some types in user assemblies couldn't be loaded when using an `OpcServer`, or `OpcClient` while dynamic type registration is enabled. > - Issue where user-defined nodes added with `OpcNodeManager.AddNode()` after starting the `OpcServer` sometimes missed the hierarchical reference from the parent node. > **2.53.0.0 (released on April 16, 2026)** > > **New** > - Introduced property `OpcServer.UseDynamic` together with types `OpcStruct`, `OpcStructField`, `OpcEnum`, `OpcEnumField`, which allow you to dynamically define data types for the `OpcServer`. > - Introduced new `OpcEnumValue` type to represent enumeration values using the OPC UA data type `EnumValueType`. > - Introduced in `OpcEnum` two static (Shared in Visual Basic) methods to retrieve the enumeration values of a typed enumeration. The way the information is retrieved can be controlled using the attributes `OpcEnumAttribute`, `OpcEnumMemberAttribute` and `EnumMemberAttribute`. > - Introduced new `OpcEnumValuesPropertyNode` to support publishing custom `OpcEnumValues` as part of the server's address space. > - Introduced new `OpcMultiStateDiscreteNode` and `OpcMultiStateValueDiscreteNode` including generic implementations for each of them. These nodes correspond in their use to the corresponding OPC UA defined node types with the names MultiStateDiscreteType and MultiStateValueDiscreteType. > - Introduced new `OpcAccessControlRole` to represent default roles and define custom roles which `OpcPrincipals` can be a member of. > - Introduced new `OpcServerSecurityRoles` to provide all default roles which are usually known by the `OpcServer`. > - Introduced new `OpcServerSecurity` properties `Roles` and `AccessControlRoles`: the first provides a set of all default OPC UA roles and the latter provides the roles currently used by the `OpcServer` (within this implementation all instances provided by the set of default roles are in the `AccessControlRoles` property). > - Introduced new `OpcAccessControlEntry` methods `Assign` and `Revoke` to control the role memberships of the principal in the entry. > - Introduced in `OpcPrincipal` the new method `IsInRole` to determine if the principal is a member of a dedicated role. > - Introduced automatic role assignment for the anonymous principal to be assigned to the Anonymous role. > - Introduced automatic role assignment for all other principals to be assigned to the `AuthenticatedUser` role (custom access control lists must ensure that authenticated principals are assigned to this role as well). > - Introduced new `OpcServer` event `CertificateChanged` which is raised whenever a session with an identity which is a member of the `SecurityAdmin` role changes the certificate of the server. > - Introduced support for GDS Push Management using `ServerConfigurationType`, `UpdateCertificate`, `TrustList` and role-based authentication using the `SecurityAdmin` role. To enable GDS Push Management the custom implementation of the `OpcServer` must provide at least one ACL entry which is assigned to the `SecurityAdmin` role. > > **Fixed** > - Issue with duplicated child references for nodes which use inline default foundation defined `NodeState` instances representing a whole tree of nodes, where children are defined by the `NodeState` and not by the user code. This applies since version 2.51.4.1 to user-code created complex foundation nodes which are not imported from a NodeSet. ### 2.52 > **2.52.0.0 (released on March 13, 2026)** > > **New** > - Introduced new abstract subtypes `OpcDiscreteItemNode` and `OpcDiscreteItemNode` of the base class `OpcDataItemNode`. > - Introduced new subtype `OpcTwoStateDiscreteNode` of the base class `OpcDiscreteItemNode`. > - Introduced support for new security policy algorithms `Aes128_Sha256_RsaOaep` and `Aes256_Sha256_RsaPss`. > > **Fixed** > - CTT issue with wrong status code `BadSessionClosed` instead of `BadNoSubscription` if a session requests a publish without any subscription. > - Issue with automatic node identifier assignment not working for `ShelvingState` in `OpcAlarmConditionNode`. > - Issue with not initialized ValueRank attribute after creating a non-generic `OpcVariableNode` instance without passing a value. ### 2.51 > **2.51.4.1 (released on February 18, 2026)** > > **Fixed** > - Issue with duplicated child references for nodes imported from NodeSets, especially using HasComponent references. > **2.51.4.0 (released on February 18, 2026)** > > **New** > - Introduced new `OpcServer.EstimatedReturnTime` property to support CTT compliance. This new property will directly update the value of the corresponding node at `Objects/Server/EstimatedReturnTime` to support clients to subscribe to value changes of the node to receive the latest estimated return time of the server, before it is about to shut down and to handle any reconnect logic accordingly. > - Enhanced `OpcNodeModel` with additional overloads to `CreateByDefault`, `OmitByDefault` and `OmitOptionals` with an additional boolean parameter `recursive` to control whether the defaults and directives are to be applied to the model and to its children or not. > - Added support for model conditional creation of the optional LastTransition node in state machine nodes. > - Added logic to support server related operation limits (using `OpcServer.OperationLimits.AutoDetermineLimits`) according to CTT compliance. > - Revised implementation of internal `OpcOperationLimiter` to provide more practical default limits, if `AutoDetermineLimits` is enabled. > **2.51.3.0 (released on February 12, 2026)** > > **New** > - Introduced client-side support of `ResendData` using `OpcSubscription.ResendData` to query current values of MonitoredItems in reporting mode. > > **Fixed** > - Issue in the OPC UA server to correctly handle pending `ResendData` requests, especially if the current value did not change in the meantime. > - Issue which caused type `OpcNodeId` in structured data type definitions to be mapped to `ExpandedNodeId` instead of NodeId since version 2.50.0. > - Issue that could cause values set using `OpcVariableNode.Value` not to be added to the `OpcNodeHistorian`'s history when using a custom data type. > - Issue in traversal automatic node identifier assignment introduced with version 2.50 if standard nodes are created with children whose relative tree depth is greater than one. > - Issue with importing NodeSets that contain type definitions which are not in hierarchical order. > **2.51.2.0 (released on January 12, 2026)** > > **Fixed** > - Issue that could cause `OpcClient.Connect()` to fail when `UseDynamic` is enabled and the server provides one or more type dictionary nodes that returned a `BadNotReadable` status when reading them. In that case, the error is now ignored and an empty type dictionary is used. > **2.51.1.0 (released on November 27, 2025)** > > **Fixed** > - Wrong status code returned by `ActivateSession` when an invalid session identifier or an empty client signature was specified (CTT compliance). > - `PolicyId` of `UserTokenPolicy` entries was not unique within the server in the endpoint descriptions provided by `GetEndpoints` (CTT compliance). > - When a client sends a `UserNameIdentityToken` with an empty user name, status code `BadIdentityTokenInvalid` is now returned (CTT compliance). > **2.51.0.0 (released on November 24, 2025)** > > **Changed** > - When using .NET Framework, version 4.7.2 or higher is now required. > - New parameters have been added to the method `IOpcNodeHistoryProvider.ReadHistory()` to support streaming of history values, instead of buffering all values in memory. In particular, the implementation now needs to return the values in reversed order when parameter `timeFlowsBackward` is `true`. > > **Fixed** > - Issue that caused reading the `ServerDiagnosticsNode` to return a `BadOutOfService` status even when diagnostics were enabled in the `OpcServer`. > - Issue that caused incoming connections to the `OpcServer` to fail with `BadUserTokenRejected` when using an `https:` URL. > - When a client sends a HistoryRead request with a `maxCount` value, that value is now correctly handled to split up the history values when sending the response. > - Updated ASP.NET Core dependencies to 2.3.6. ### 2.50 > **2.50.7.0 (released on October 22, 2025)** > > **New** > - Performance improvements during the creation of variable nodes (streamlined and unified initialization). > - Introduced new `OpcAutomatism` properties `UseNodeNameAsDefaultDescription` and `UseNodeNameAsDefaultSymbolicName` to support conditional initialization of the Description attribute and `SymbolicName` property of `OpcNode` instances. > > **Changed** > - Improved CTT compliance regarding `OpcNode` default initialization and conditionally removed defaults for the Description attribute and for the `SymbolicName` property. To enable the previous behavior, enable the corresponding properties in `OpcAutomatism`. > > **Fixed** > - Issue with overwritten variable node attributes provided through an `OpcNodeModel`. > **2.50.6.2 (released on October 6, 2025)** > > **Fixed** > - Issue with `InvalidOperationException`/`NullReferenceException` when creating an `OpcConditionNode` or an `OpcHistoryConfigurationNode`. > **2.50.6.1 (released on September 25, 2025)** > > **Fixed** > - Issue with `NullReferenceException` in case of NodeSet variables with undefined array dimensions. > **2.50.6.0 (released on September 21, 2025)** > > **New** > - Enhanced `IOpcNodeInfo` with `WriteAccess` and `UserWriteAccess` properties to provide the values of these attributes as well. > - Introduced new `IOpcVariableNodeInfo` as a sub-type of `IOpcNodeInfo` to distinguish variables from other nodes and provide variable node specific attributes. > - Introduced model attribute support to initialize nodes using initial attribute values defined by a model. > - Introduced new node type implementations `OpcAnalogUnitRangeNode` and `OpcAnalogUnitNode`. > > **Changed** > - Moved `Model` property and all other `OpcNodeModel` related API from `OpcInstanceNode` to `OpcNode` to ensure correct node initialization. > **2.50.5.0 (released on September 17, 2025)** > > **New** > - Enhanced authentication with several mechanisms to protect against brute force attempts. > - Introduced new property `OpcServer.AuthenticationLimits` to control new brute force protection limits applied while authenticating. > - Updated node types to version 1.05.03. > - Introduced `BadUserAccessDenied` in case of an invalid identity used to change the identity of an existing session (CTT compliance). > - Introduced new constructors to support additional subclasses using an `OpcNodeModel` parameter for `OpcConditionNode` (including its subclasses), `OpcOrderedObjectNode` and `OpcFileNode`. > > **Changed** > - Reworked request validation to validate first the contents of the request and then validate if the operation requested is granted. In addition, any diagnostics (including null references) are provided only if requested. This addresses CTT compliance. > > **Fixed** > - Issue with `NullReferenceException` in `OpcContext` if created from an `OpcOperationContext`. > - Issue with `NullReferenceException` in `OpcNodeId` when `ValueAsString` is queried on an `OpcNodeId.Null` instance. > - Issue with `NullReferenceException` (since version 2.50.4) when creating an `OpcDataItemNode` (or one of its subclasses) after the server has started. > - Issue with duplicated parent-child references while importing NodeSet files using typed instances. > **2.50.4.0 (released on September 9, 2025)** > > **New** > - Added property `OpcServerInfo.ProductUri` for setting the `ProductUri` in the BuildInfo variable of the `ServerStatus` variable. > - Introduced new generic implementation of `OpcMethodNode`: The `OpcMethodNode` supports typed delegates and the change of the target callback to use. > - Introduced support for `ResendData(...)` on the MonitoredItems of subscriptions. > - Introduced new `OpcServer.OperationLimits` property to control the operation limits of the server (for the moment only with "unlimited" or automatically determined limits according to available system resources). > > **Changed** > - Wrong `DefaultReferenceTypeId` Organizes of `OpcFolderNode` and adopted use of HasComponent instead. This change addresses CTT compliance. > - `ServerDiagnostics` no longer provides children and any explicit read/write operations on the child nodes using their NodeId result in `BadOutOfService`. This behavior applies for disabled `ServerDiagnostics` and addresses CTT compliance. > > **Fixed** > - Issue with `SemanticsChanged` status code (`0x4000`) not reported for MonitoredItems when writing values to semantic properties, for example of an `OpcAnalogItemNode`. > - Issue with duplicated references while browsing the address space of imported nodes. This was especially the case for method nodes regarding their Output-/InputArguments. > - Issue with non-compliant read results of the `InverseName` attribute of `ReferenceTypes` to assure that a `BadAttributeIdInvalid` is provided instead of a null reference (Nothing in Visual Basic). > - Wrong status code from `BadSessionIdInvalid` to `BadSubscriptionIdInvalid` used in server subscriptions when accessing the subscription of a different session. > - Wrong status code from `BadIdentityTokenInvalid` to `BadIdentityTokenRejected` in cases where the impersonation of an identity token fails. This change addresses CTT compliance. > **2.50.3.0 (released on July 17, 2025)** > > **Fixed** > - Issue with `NullReferenceException` when creating an `OpcAlarmConditionNode` instance (or one of its subclasses) in the `OpcServer`. > **2.50.2.0 (released on July 7, 2025)** > > **New** > - The `OpcServer` now provides the server's local time zone information in the `LocalTime` property of the Server object. > - Introduced support for model change tracking and reporting. > - Added `OpcAutomatism.RaiseModelChangeEvents` property to globally enable or disable model change tracking and reporting. > - Added `OpcNode.SuspendModelChangeEvents(...)` and `OpcNode.ResumeModelChangeEvents(...)` methods to control model change tracking and reporting on node level. > > **Fixed** > - Issue with decoding structured data types when the first field is optional. > - `OpcNodeManager.GetNode(string)` did not always return `OpcFiniteStateMachineNode` instances. > - Issue receiving `ModelChangeEvent` and GeneralModelChangeEvent data in `OpcClient`. > - Issue with `NullReferenceException` in `OpcGeneralModelChange` when the `Changes` property of the data store was a null reference (Nothing in Visual Basic). > **2.50.1.0 (released on June 16, 2025)** > > **New** > - Added support of method members in `NodeType` reflection. > > **Fixed** > - Issue with state machines with zero as their transition number for every transition. > - Issue with state machines with states where zero is an invalid state number. > **2.50.0.0 (released on June 12, 2025)** > > **New** > - Introduced support of `NodeTypeSystem` information in the `OpcServer` and `OpcContext`. > - Implemented support of typed node instance creation when importing nodes from a NodeSet file. > - Improved dynamic creation of typed node instances while loading a NodeSet. > - Enhanced the `OpcFiniteStateMachineNode` to determine states and transitions from node type information if no attributes are given to define states and transitions for the state machine. > - Introduced thread local `OpcContext` (using new `OpcContext.Current` property) to support scenarios where an `OpcContext` is required but not given by any parameter. This currently applies to server code only. > - Added properties `OpcNodeManager.NodeSetImportOptions` and `OpcNodeSetManager.ImportOptions` to specify to include structure fields from parent types in DataTypeDefinition attributes when importing them from NodeSets. > - Added new `OpcEncoding.Empty()` method to provide empty encoding arrays. > - Added new `OpcEncodingMask.DefaultAuto` to simplify generic encoding definitions. > - Introduced thread local `OpcContext` (using new `OpcContext.Current` property) to support scenarios where an `OpcContext` is required but not given by any parameter, for example in the constructor of some node. > - Introduced `OpcContext.OfNode` method to switch into the context of a dedicated node. In addition, enhanced `AddChild` and `RemoveChild` methods in `OpcInstanceNode` to add/remove the child to/from the node manager whose context is used for this operation. As a result, the child node is added/removed to/from the same node manager as the node whose context is passed to `AddChild` and `RemoveChild`. > - Added `OpcServer.RegisterNamespace` and `OpcServer.RegisterNamespaces` methods to preregister known namespaces to ensure they are registered in a specific order to assign specific namespace indexes per namespace. > - Introduced `OpcNodeManager.IsNodeReadyToPublish(...)` to determine whether any applied node changes are waiting to be published by at least one MonitoredItem. > - Introduced the recursive support to get from an `OpcSession` to its `OpcSubscriptions` and from them to their `OpcMonitoredItems`. > - Introduced new `OpcNode.ChangesUnhandled` event which is raised whenever changes are to be applied on a node, but there exists no MonitoredItem accepting (for example by filtering) and handling the node changes. > > **Changed** > - When `OpcClientSecurity.UseOnlySecureEndpoints` is set to `true`, the `OpcClient` now only selects endpoints with a `SignAndEncrypt` mode, and no longer selects ones with a `Sign` mode, because the latter does not provide confidentiality. To use the previous behavior of selecting endpoints with a `Sign` or `SignAndEncrypt` policy, set `client.Security.EndpointPolicy` to one with that mode, and set `OpcClient.Security.AutoUpgradeEndpointPolicy` to `true`. Alternatively, to select the "best" endpoint offered by the server, set `OpcClient.Security.UseHighLevelEndpoint` to `true` (but note that this does not provide security). > - When creating an event filter with `OpcEventFilterFactory.Select()`, the type identifier of the `BaseEventType` is now used by default in the simple attribute operands (as it was before version 2.32.0.0), to ensure that when specifying multiple event types that may have fields with the same name, all fields can be received. To use the previous behavior of specifying the actual event type identifier in the simple attribute operands, specify `OpcEventFieldSelectOptions.UseExplicitEventTypeIds` in `OpcEventFilterFactory.Select()`. > > **Fixed** > - `NullReferenceException` when importing a NodeSet containing a `FiniteStateMachine` without a LastTransition child node. > - `NullReferenceExceptions` while comparing two Number struct values if the underlying value is a null reference (Nothing in Visual Basic). > - Issue which caused clients to receive a `BadNotSupported` error when trying to establish a new connection to the server after one client subscribed to audit events. > - Issue which could cause `OpcEngineeringUnitInfo.CommonCode` to return a string containing a NUL character. > - Issue which could cause an `OpcException` when reading a structured data type with an array of nested structured data types when `OpcClient.UseDynamic` was enabled. > - Issue which could cause the `OpcServer` to accept client connections using untrusted certificates even when `OpcSecurity.AutoAcceptUntrustedCertificates` was set to `false`. > - Issue which could cause the `OpcClient` to connect to endpoints with a `None` policy mode when that was the only policy offered by the server, even if `OpcClientSecurity.UseOnlySecureEndpoints` was set to `true`. > - Issue with decoding structured data types when a null value occurred for an array field. > - Issue with `InvalidCastException` when reading a structured data type containing an array of structured data types. > - `IndexOutOfRangeException` when importing a NodeSet where a `VariableNode` specifies a ValueRank of 0. > - [Client SDK] The `OpcData.Decode(...)` methods that were intended to be added with version 2.40.0.0 were missing in the Client SDK (`Opc.UaFx.Client`). ## 2.40–2.42 (2023–2024) ### 2.42 > **2.42.5.0 (released on December 3, 2024)** > > **Fixed** > - `NullReferenceException` that was thrown and caught internally when processing an empty publish response. > **2.42.4.0 (released on October 21, 2024)** > > **New** > - Introduced implicit cast operator from `UserIdentityToken` to `OpcIdentityToken`. > > **Changed** > - Updated `Portable.BouncyCastle` dependency to version 1.9.0, to fix a vulnerability. > > **Fixed** > - Invalid generated SwitchValue field for union types in the DataTypeDefinition attribute. > **2.42.3.0 (released on September 10, 2024)** > > **New** > - Added support for subscription licenses. > > **Fixed** > - Issue that could cause `OpcClient.State` to be stuck in `Connecting` when calling `OpcClient.Disconnect()`, while at the same time another thread calls methods like `OpcClient.CallMethod()`. > **2.42.2.0 (released on August 22, 2024)** > > **New** > - Classes `OpcAccessControlList` and `OpcUserIdentity` are now subclassable, and custom `OpcAccessControlList` instances can be added to the `OpcServer` via `OpcServerSecurity.AddAccessControlList()`. > **2.42.1.0 (released on July 25, 2024)** > > **Fixed** > - Issue where a side-effect in an internal class could cause the `OpcNodeIdFactory.Create()` method not to be called for certain node instances. > - Issue causing an `InvalidOperationException` in `OpcFiniteStateMachine.ChangeStateTo()` due to an incorrect `OpcNodeId` comparison. > **2.42.0.1 (released on June 7, 2024)** > > **Fixed** > - Invalid generated length field for arrays in the DataTypeDefinition attribute in subclasses when the field is declared in the base class. > **2.42.0.0 (released on June 5, 2024)** > > **New** > - Introduced new property `OpcAutomatism.UseNullInsteadOfEmptyArrays` to control several array / list / collection properties regarding their supported / encoded values. When setting this property to the value `true`, some properties will no longer set a null reference (Nothing in Visual Basic) to an empty array / list / collection. In addition they encode these values using an array size equal to `-1`. If a server / client "requires" an empty array / list / collection, the `OpcAutomatism.UseNullInsteadOfEmptyArrays` property has to be set to the value `false`. This results in empty array / list / collection values which are encoded using an array size equal to zero. > > **Changed** > - `OpcArgument.ArrayDimensions` and `OpcArgumentInfo.ArrayDimensions` now support null references (Nothing in Visual Basic) when enabled via `OpcAutomatism.UseNullInsteadOfEmptyArrays`. This means whenever a server provides a value of `null` for the `ArrayDimensions` this property will now return a null reference (Nothing in Visual Basic) as well. > > **Fixed** > - The `OpcClient` no longer selects an endpoint with an unknown security algorithm (which would fail to connect) when using default settings and there is at least one endpoint available with a known security algorithm. > - Issue that caused `OpcNode.Id` to change to a different object instance when a client read the NodeId attribute of a node. > - Issue causing an invalid namespace index to be specified in the `DataTypeId` of a structured data type pointing to another structured data type. > - `OpcNodeManager.GetNode(string)` will now also find child nodes that exist in a different namespace (as long as the namespaces are managed by the same `OpcNodeManager` instance). > - Invalid generated length field for arrays in the DataTypeDefinition attribute. > - Memory leak in `OpcServer` that occurred every time a client sent a GetEndpoints request. > - Added a workaround for some OPC Classic servers that don't support reading specific properties together with other, regular properties. ### 2.41 > **2.41.1.0 (released on January 18, 2024)** > > **Changed** > - Updated `Microsoft.AspNetCore.Server.Kestrel.Core` dependency to version 2.1.25, to fix a vulnerability. > > **Fixed** > - Issue that caused a memory leak in the `OpcClient` when repeatedly calling `OpcClient.BrowseNodes()` or accessing file nodes with class `OpcFileMethods`, `OpcFileStream` or `OpcFileInfo`. > - Issue that could cause the `OpcClient` to incorrectly send Read requests (from the keep-alive timer) even when the ActivateSession call hasn't completed yet. > **2.41.0.0 (released on December 2, 2023)** > > **Changed** > - User authentication in the `OpcServer` is now done only once during `ActivateSession`, instead of doing it for each request separately. > > **Fixed** > - Issue with `OpcVariableNodeInfo.IsArray` and `OpcVariableNode.IsArray` incorrectly returning `false` (the former since version 2.33.0) for an array with 3 or more dimensions. > - Issue with a deadlock occurring when calling `OpcClient.Disconnect()` or `OpcClient.Dispose()` while at the same time event subscriptions were active. > - Issue that caused the `OpcClient.State` not changing to `Reconnecting` when a connection break was detected while an operation like `ReadNodes()` was still executing. > - Issue that prevented creating an event filter from an `OpcNodeId` if it was using a resolved namespace. > - Issue that caused a memory leak when repeatedly creating (and throwing away) `OpcMethodNode` instances where a Delegate instance is passed. > - Issue that caused reflected type fields to be declared in a wrong order when the type implements an interface. ### 2.40 > **2.40.0.0 (released on October 23, 2023)** > > **New** > - Introduced new `OpcContext.Enter(...)` methods to enter into a local context to perform non client / server scenarios. > - Enhanced `OpcDataTypeInfo` to support `ExtensionObjects` as system type as well (`IsSystemType` property). > - Introduced new `OpcData.Decode(...)` methods to manually decode a binary encoded data stream/buffer to a structured object. > - Introduced explicit support for encoding/decoding/use of `ExtensionObjects`. > - Improved performance when receiving custom event data for the first time. > - Introduced new `OpcNodeSet.Load(string, OpcNodeSetLoadOptions)` method to provide more details about the NodeSet file to load. > > **Fixed** > - Issue with wrongly calculated encoding mask when using explicit encoding. > - Issue with encoding/decoding subtypes of built-in data types according to their base types. > - Issues with encoding/decoding `ExtensionObjects` in custom structured data types. > - Issue with nested event type fields like ActiveState/Id not being reported correctly since version 2.32.0. > - Issue with mixed data types which are defined using `DataTypeDescriptions` and `DataTypeDefinitions` while the definitions use different field types. The descriptions are now prioritized. > - Issue with event subscriptions not working since version 2.29.0 when no `OpcEventFilter` was specified. ## 2.30–2.33 (2022–2023) ### 2.33 > **2.33.0.0 (released on September 11, 2023)** > > **New** > - Enhanced `OpcNodeContext` with new `NodeManager` property which references the `OpcNodeManager` in whose context an operation is executed. > - Introduced `OpcMethodNode.Call(...)` method to invoke an implemented method node using a custom context independent from a "client call". > - Introduced the methods `Close(...)`, `GetPosition(...)`, `Open(...)`, `Read(...)`, `SetPosition(...)` and `Write(...)` to invoke the implemented methods of an `OpcFileNode` using a custom context independent from "client calls". > - Improved performance of event filter creation using only event types of the node type system provided by the server. > - Introduced support of data types which are only declared using a data type definition and no longer a data type description. > - Introduced support of dynamic union data type resolution and representation using the `OpcDataObject` class. > > **Changed** > - `OpcContext.Empty.SessionId` no longer provides a null reference (Nothing in Visual Basic). Instead it provides `OpcNodeId.Null`. > - Changed access modifiers of `OpcNodeManager.AddNode(...)` and `OpcNodeManager.RemoveNode(...)` methods from `protected` to `public` for improved usability. > - Evaluation of `OpcVariableNodeInfo.IsArray` now uses the ValueRank value instead of the ArrayDimensions to decide whether the Value attribute provides an array. ### 2.32 > **2.32.0.0 (released on August 28, 2023)** > > **New** > - Enhanced DCOM security options with properties to configure `AuthenticationService`, `AuthorizationService` and `ProxyCapabilities` from user code. > - Introduced new `Name` property in `OpcDataTypeAttribute` to define a different name per DataType as used by the implementing .NET type. > - Introduced support of lazy initialization of custom `OpcData` store implementations with support of a default constructor. > - Introduced new `IsUnion` property in `IOpcDataTypeInfo` to indicate whether a data type is a union data type. > - Introduced new interface `IOpcUnion` to implement custom union data types using this interface type. > - Introduced typed support of the abstract Number data type which supports the encoding of all primitive numeric data types. > - Introduced new `OpcSubscriptionSetup` class to create a new subscription with all properties preset at once. > - Introduced new `OpcClient.CreateSubscription(...)` method which uses an `OpcSubscriptionSetup` to create a new `OpcSubscription`. > > **Fixed** > - Added a reference to `System.Text.Encodings.Web` 4.5.1 (for the NuGet package), to fix a vulnerability warning caused by the transitive reference through `Microsoft.AspNetCore.Server.Kestrel` 2.1.3/1.1.3. > - Issue with not reported events at the "Server" node as long as no MonitoredItem has been created to monitor the event expected in its node hierarchy where it resides. > - Missing implicit call to `ApplyChanges` using `OpcEventNode.ReportEvent(...)`. > - Issue with always used type identifier of the BaseEventType in the simple attribute operands in an `EventFilter`. > - Issue to assure that equal Start and End times when reading processed history values do not result in an infinite loop and memory consumption. > - Issues with deadlocks when using `UseDynamic` and subscriptions consuming structured data types represented using the `OpcDataObject` class. ### 2.31 > **2.31.0.0 (released on May 17, 2023)** > > **Changed** > - Updated `Newtonsoft.Json` dependency to version 13.0.3, to fix a vulnerability. > - The UA Wrapper Server for OPC Classic connections will now always generate a new application certificate, instead of trying to load one from the client's certificate store. > - When no port is specified on an `opc.com:` URL, the port for the classic wrapper server is no longer derived from the `classID` and `progID`, but instead a free dynamic port number is determined. This facilitates using multiple `OpcClients` with the same `opc.com:` URL at the same time. > > **Fixed** > - Issue when updating the `OpcServer`'s `ApplicationUri` from the selected certificate, which would only be applied for the second start instead of for the first start, which would cause the Reconnect mechanism of the `OpcClient` to fail. ### 2.30 > **2.30.0.0 (released on December 7, 2022)** > > **New** > - Added debug-level trace logging when using break monitoring with the OPC Classic UA Wrapper Server. > - Introduced `OpcNodeId.Resolution.InheritParentNamespace` property to control the inheritance of the namespace of parent nodes to their children. > - The default node identifier resolution now uses the namespace (if not a default namespace) of the parent node to define the "automatic" node identifier of a node (if `OpcNodeId.Resolution.InheritParentNamespace` is `true`; the default value). > > **Changed** > - The behavior of starting and stopping an OPC Classic UA Wrapper Server is now more deterministic, as each `OpcClient` uses a dedicated wrapper server, which is now also stopped when the `OpcClient` disconnects. > - The method `OpcCertificateIdentity.Matches()` is now virtual to enable custom identity comparison. > - The `OpcEvent.EventId` property now provides the underlying ByteString instead of a byte-array (before the ByteString was introduced). > > **Fixed** > - Issue with `ArgumentOutOfRangeException` being thrown when creating an `OpcFiniteStateMachineNode` without defining states via attributes. > - Issue with `NullReferenceException` when an `OpcFiniteStateMachineNode` is created after the `OpcServer` has already been started. > - `OpcEvent.GetValue(string)` correctly returns a ByteString value when type parameter `T` is `Opc.UaFx.ByteString`. > - Issue with `ArgumentException` in `OpcClient.Connect()` when the current `AppDomain`'s friendly name contains non-path characters (for example, in an Office VSTO add-on). ## 2.20–2.29 (2021–2022) ### 2.29 > **2.29.0.0 (released on September 16, 2022)** > > **New** > - Added property `OpcClientInterfaces.UseBreakMonitoring` to temporarily stop the UA Wrapper Server for OPC Classic connections while a (DCOM) connection break to the OPC Classic server is detected. > - Introduced `OpcNamespace.GetNextId()` method to query the next free numerical `OpcNodeId` from the `OpcNamespace`. > - Introduced a set of new attributes to specify `OpcStateMachineNode` specific states and their transitions. > - Introduced new `OpcStateNode` class to represent the OPC UA `StateType`. > - Introduced new `OpcTransitionNode` class to represent the OPC UA `TransitionType`. > - Introduced support to configure custom `OpcFiniteStateMachineNodes` using the new state / transition attributes to set up the initial state, the state nodes and the transition nodes using numerical or enumeration values. > - Introduced `OpcFiniteStateMachineNode.ChangeStateTo()` method to change the current state of the `StateMachine` to another state. The method checks whether the target state exists and whether a transition exists from the current state to the new state. > > **Changed** > - `OpcNode.AddNotifier` is no longer supported on other types than `OpcObjectNodes` and their subclasses. > > **Fixed** > - Issues with missing data type information for the abstract data type "Structure" (`i=22`). > - Issues accessing the `OpcTransitionVariableNode.VariableId/Node` properties. > - Issues accessing the `OpcFiniteTransitionVariableNode.VariableId/Node` properties. > - Issues accessing the `OpcStateVariableNode.VariableId/Node` properties. > - Issues accessing the `OpcFiniteStateVariableNode.VariableId/Node` properties. ### 2.28 > **2.28.1.0 (released on September 2, 2022)** > > **New** > - Introduced inline initialization of encoding mask related "reserved" fields using a bit-array. > > **Fixed** > - Issue with hostname/IP address not taken into account when generating the port for the OPC Classic UA Wrapper Server. > - Issue with OPC Classic client still calling `IOPCBrowseServerAddressSpace.ChangeBrowsePosition()` with `OPC_BROWSE_TO` even though `OpcClient.Interfaces.DataAccess.SupportsBrowseTo` was set to `false`. > - Issue with wrong ValueRank and ArrayDimensions in data type definitions of structures using another field to define the length of an array-field. > **2.28.0.0 (released on August 19, 2022)** > > **New** > - Enhanced inline definition of `DataTypeDictionaryNodes` to only provide one if a data type description of a data type is to be published. > - Unknown (user) defined data types are now resolved using the events `OpcData.TypeResolve` and `OpcClient.TypeResolve` using the corresponding encoding identifier and `OpcNodeId.Null` for the data type identifier. > > **Changed** > - Disabling `OpcAutomatism.UseDynamicTypeRegistration` resulted in a deferred dynamic type registration at the time a custom data type is manually registered. > > **Fixed** > - Issue with `ArgumentException` whenever the `Value` property of an `OpcStateVariableNode` or `OpcFiniteStateVariableNode` has been changed. > - Issue with `OpcData.TypeResolve` where the event arguments passed provided the encoding identifier as the type identifier. This has been solved and the encoding identifier is provided as part of the Encoding supplied. > - Issue with `OpcClient.TypeResolve` not being invoked for every data type. > - Issue with not encoded dynamically resolved data types. > - Issue with missing leading array length if a data type uses a fixed length field. > - Issues with inline registered data types although `OpcAutomatism.UseDynamicTypeRegistration` has been disabled. > - Issues with enumerations described in a different `DataTypeDictionary` than structured data types when using fully qualified data type identifiers (value and namespace URI). > - Issue with importing NodeSets using structure data type definitions without an explicit base type identifier. > - Issue with data type load errors in some third party clients when accessing `DataTypeDictionaries` only declaring enumerations. > - Issues when selecting an endpoint by constraints, to ignore endpoints that have `Mode == None` but `Algorithm != None` and fallback if there is no other endpoint available. ### 2.27 > **2.27.0.0 (released on June 27, 2022)** > > **New** > - Added new `NumberInList` property to `OpcOrderedObjectNode` to determine the current position of a node within the server. > - Added new `OpcClient.TypeResolve` event to resolve user defined types according to client / session related conditions. > - Improved `OpcDataTypeDictionary.GetType(OpcEncoding)` to consider encodings without expanded node identifiers. > - Introduced new protected static (Shared in Visual Basic) `OpcNode.DefineModel` methods to define node type dependent modeling rules for its whole node model. > - Introduced `IOpcDataTypeMapper` and its default implementation `OpcDataTypeMapper`. > - Introduced new `OpcData` method to register, determine and unregister custom data type mappers. > - Introduced new `OpcDataTypeMapper.Convertible` and `OpcDataType.Delegate` methods to construct simple custom data type mappers. > > **Fixed** > - Issue with `OpcPropertyNode` not being added to its parent if the type parameter represents a custom data type. > - Issue with `BadNodeIdUnknown` on EnumStrings if a custom enumeration type is defined using EnumStrings. > - Issue of multiple hierarchical references between parent and child nodes if a subtype of the default reference type is used for a child node. > - Regression with enhancement of `IOpcNodeInfo.Child` overloads and their implementations. ### 2.26 > **2.26.0.1 (released on April 13, 2022)** > > **Fixed** > - Regression which disables subclassing of custom data types without data type attributes. > **2.26.0.0 (released on April 13, 2022)** > > **New** > - Introduced option to manually define which data types are to be defined using data type definitions and/or data type descriptions using the `OpcDataTypeAttribute`. > - Added new `Declarations` property to `OpcDataTypeInfo` to indicate in which way the data type has been declared. > - Added support for arrays of Bit members to define the encoding bits no longer only using scalar encoding bit members. > - Enhanced OPC Watch with new upload button to write a file to a file node (the existing file content is truncated before). > - Introduced new `OpcNodeId.Resolution` property to configure the ways node identifiers are resolved if no custom node identifiers are used. > - Introduced new `OpcNode` events `BeforeAdd` and `AfterAdd` to handle conditions/states at the time a node is being or has been added to the address space of the server. > - Introduced new `OpcNode.Implement` method to finalize the node creation before it can be used for the first time. > - Enabled support of implementing standard OPC UA interfaces. > - Introduced `OpcOrderedObjectListNode` as default implementation of the `OrderedListType`. > - Introduced abstract `OpcOrderedObjectNode` as default implementation of the `IOrderedObjectType` / `IOpcOrderedObjectNode`. > > **Fixed** > - Issue with not respected custom data type encoding identifiers. > - Issue with cached application certificates using a custom application store path. ### 2.25 > **2.25.0.0 (released on March 22, 2022)** > > **New** > - Updated OPC UA Stack Types to version 1.04.368. > - The server defined data type nodes no longer provide a data type definition in case of an opaque data type. Any read request results in `BadAttributeIdInvalid` and now behaves the same way as built-in opaque data type nodes behave. > - Introduced `IOpcData` to provide a way to subclass data types which are programmatically not inheritable. > - Different improvements for lazy and cached data type metadata processing to improve performance of encode/decode operations. > - Introduced new `OpcClientSecurity` related properties to configure the `AuthenticationLevel` and `ImpersonationLevel` the client shall use when connecting to an OPC Classic server. > > **Changed** > - Default size of (auto) encoding mask from one bit to 32 bit to improve usability of the by default expected 32 bit encoding mask. > > **Fixed** > - Issue with (auto) bit number used when a data type member is marked as optional using `OpcDataTypeMemberSwitchAttribute`. > - Issue with reloading the server's data type system after a connection has been lost and re-established. ### 2.24 > **2.24.0.0 (released on March 9, 2022)** > > **New** > - Introduced new `IOpcAsyncMethodCommand` interface to implement asynchronous commands. > - Introduced new default `OpcMethodCommands.Execute` to provide a custom generic command method to be executed using a command object. > - Introduced new default `OpcMethodCommands.ExecuteAsync` to provide an async custom generic command method to be executed asynchronously using a command object. > - Introduced support of `IOpcAsyncMethodCommand` and delegates pointing to a method which returns a `Task` or `Task`. Either are executed asynchronously on method call. > - Introduced new `OpcAutomatism.UseAsyncMethodCalls` property to globally control the execution of method calls for every server and all its node managers. > - Introduced new `OpcNodeManager.UseAsyncMethodCalls` property to locally control the execution of method calls of methods defined by the node manager. > - Introduced support for OPC UA `NumericRange` information using the new `OpcRange` structure. > - Enhanced `OpcReadNode` with new `Range` property to support reading a range of elements in an attribute. > - Enhanced `OpcWriteNode` with new `Range` property to support writing a range of elements in an attribute. > - Introduced additional `OpcClient.ReadNode` method overloads to provide an `OpcRange` to read a range of elements in an attribute. > - Introduced additional `OpcClient.WriteNode` method overloads to provide an `OpcRange` to write a range of elements in an attribute. > > **Changed** > - The `OpcNodeAccessToken.IndexRange` is now obsolete, use new `OpcNodeAccessToken.Range` property instead. > - The property type of `OpcReadVariableValueContext().Range` has been changed from `Ua.NumericRange` to `OpcRange`. > - The property type of `OpcWriteVariableValueContext().Range` has been changed from `Ua.NumericRange` to `OpcRange`. > - The property type of `OpcReadPropertyValueContext().Range` has been changed from `Ua.NumericRange` to `OpcRange`. > - The property type of `OpcWritePropertyValueContext().Range` has been changed from `Ua.NumericRange` to `OpcRange`. > > **Fixed** > - Issues with strict `XmlReflectionImporter` used in Mono/Xamarin while mapping class information (including expected attributes and property types). ### 2.23 > **2.23.0.0 (released on March 2, 2022)** > > **New** > - Introduced new `Tag` property in `OpcServiceCommand` to assign custom metadata bound to a specific command. > - Introduced `Load`, `Parse` and `TryParse` methods on `OpcDataTypeDictionary` to provide different ways to consume an XML serialized dictionary in any possible way. > - Overall review of `OpcReadHistoryDetails`, `OpcReadNodeHistoryDetails`, `OpcReadNodeHistoryRawDetails` and `OpcReadNodeHistoryModifiedDetails`. > - Added missing documentation to `OpcReadHistoryDetails`, `OpcReadNodeHistoryDetails`, `OpcReadNodeHistoryRawDetails` and `OpcReadNodeHistoryModifiedDetails`. > - Introduced new `ReturnBounds` property in `OpcReadNodeHistoryDetails`. > - Introduced new `ReadNode`[s]History[Modified] methods to `OpcClient` to support custom `OpcReadHistoryDetails`. > > **Fixed** > - OPC Classic connections now specify `RPC_C_AUTHN_LEVEL_PKT_INTEGRITY` for DCOM to handle the hardening changes for CVE-2021-26414. ### 2.22 > **2.22.0.1 (released on February 25, 2022)** > > **Fixed** > - Issue calling `Acknowledge`, `Confirm` and `AddComment` on `OpcCondition` and `OpcAcknowledgeableCondition` instances. > **2.22.0.0 (released on February 11, 2022)** > > **New** > - Introduced new `CreateArray` method in `OpcArrayDimensions`. > - Introduced new `GetDataType` methods in `OpcContext` to determine context sensitive data type information. > - Introduced support of `OpcModelChangeEvent`[Node] and `OpcGeneralModelChangeEvent`[Node] including its `OpcModelChangeItem` and `OpcModelChangeActions`. > - Custom model change event propagation/handling using the new `OpcModelChangeEventNode` and `OpcGeneralModelChangeEventNode`. > - Introduced inline event compression of model change events whenever an event snapshot of an `OpcGeneralModelChangeEventNode` is to be reported. > > **Fixed** > - Issue with wrong definition of `ValueRank` using `OpcArguments` constructor accepting custom array dimensions. > - Issue with new DataTypeDefinition when defining a custom enumeration type before it is used for the first time. ### 2.21 > **2.21.0.0 (released on February 1, 2022)** > > **New** > - Client API: Prepared OPC UA 1.04 compatible support of data type definitions using data type nodes' new DataTypeDefinition attribute. This enhancement is backward compatible with OPC UA 1.03, because `DataTypeDictionaries` and `DataTypeDescriptions` including the `DataTypeEncodings` are still used to determine declared and described data type information. > - Server API: Introduced OPC UA 1.04 compatible support of data type definitions using data type nodes' new DataTypeDefinition attribute. This enhancement is backward compatible with OPC UA 1.03, because `DataTypeDictionaries` and `DataTypeDescriptions` including the `DataTypeEncodings` are still used to declare and describe a data type. ### 2.20 > **2.20.4.0 (released on January 14, 2022)** > > **New** > - Clients are now notified with the status code `BadNodeIdUnknown` when a node subscribed is deleted later. > **2.20.3.0 (released on January 4, 2022)** > > **Fixed** > - Issue with `OpcNamespace.Resolve()` that caused `OpcNamespaceCollection.ResolveValue()` not to work correctly. > - `IndexOutOfRangeException` when using a non-generic `OpcAnalogItemNode` in the server. > - Issue with `StackOverflowException` when (implicitly) converting a `Byte[]` as a null reference to ByteString. > **2.20.2.0 (released on October 20, 2021)** > > **Fixed** > - Issue with duplicated error strings in `OpcException.Message`. > - Issue with `OpcMethodNode` using wrong callback target. > **2.20.1.0 (released on October 8, 2021)** > > **New** > - Introduced new `OpcEnumAttribute` to control the definition of the enum members using EnumStrings or EnumValues. Additionally the `OpcEnumAttribute` provides properties to control the existing automatisms per enumeration type. > > **Fixed** > - Issue when connecting to a server using `https:` URLs on .NET Framework. > **2.20.0.0 (released on September 17, 2021)** > > **New** > - `OpcClient` now provides node type information for event, object and variable types. > - `OpcNode` provides new `RegisterType` and `UnregisterType` methods to define/undefine custom node types. > - `OpcNode` provides new `GetType` and `GetTypeInfo` methods to determine `System.Type` and `OpcNodeTypeInfo` instances used to define/describe a node type. > - `OpcInstanceNode` provides new `GetNodeValue` and `SetNodeValue` methods to change the Value attribute of a dedicated `OpcVariableNode` which is a child of the instance node. > - Subclassing an `OpcObjectNode` using the subclass as a custom node type definition as well results in inline created property/variable nodes for properties/fields defined in the subclass. > - Subclasses of `OpcTypeNode` were introduced to define custom node types (`OpcNodeType` and `OpcNodeType`). > - Introduced new attributes to describe custom node types (`OpcNodeTypeAttribute`, `OpcNodeTypeIgnoreMemberAttribute`, `OpcNodeTypeMemberAttribute`, `OpcNodeTypeOptionalMemberAttribute`). > - Enhanced `OpcNodeTypeSystem` class to provide Default and Current node type system related node type information. > - Members in `OpcNodeTypeInfo` to provide additional information about the type and its children/members. > - Extended data type resolution of `OpcArgument` to support lazy initialized custom data types as well. > > **Changed** > - `OpcInstanceNode` now determines its `DefaultTypeDefinitionId` using the node type used to create the instance node. > - `OpcMemberOrigins` now defines an additional enum member `Method` for method origins. > > **Fixed** > - Issue with lazy defined custom data types used for arguments in `OpcMethodNodes`. > - Issue with `BadNodeIdUnknown` while accessing/browsing the InputArguments/OutputArguments of `OpcMethodNodes` created before its dedicated `OpcNamespace` has been initialized and defined in the server (for example, before `OpcNodeManager.CreateNodes` has been executed). ## 2.10–2.19 (2020–2021) ### 2.19 > **2.19.2.0 (released on September 10, 2021)** > > **New** > - Introduced support of `IEnumerable` in `OpcNamePath`. > - Introduced new `OpcClient.GetType`(s) methods to determine any type information associated with a node identifier. > - Introduced new `OpcClient.IsSubtypeOf` method to determine whether a type is a subtype of another type. > - Introduced new `IOpcNodeInfo.Child(OpcNamePath)` method to determine a child node using a path of `BrowseNames` to follow and look up the corresponding child. > - Introduced new `ServiceName` property in `OpcServiceRequest` and `OpcServiceResponse`. > - Introduced new methods `GetResults` and `GetResultExceptions` in `OpcServiceResponse` to determine request and command related exception information. > - Introduced new `OpcServer.RequestJudgement` event to handle request issues and decide whether an impeachment is to be dismissed. For example, an outdated request (`BadInvalidTimestamp`) can still be allowed through the `Dismiss` property. > > **Changed** > - Removed unnecessary new lines in the string representation of `OpcException` instances. > > **Fixed** > - Misleading use of the same base type (that is, the topmost node type) for the topmost base type when examining the type hierarchy of a node type (for example, `BaseType` of `BaseEventType` was `BaseEventType`). > - Possible `NullReferenceExceptions` using the `OpcClient.GetDataType` and `OpcClient.GetNodeType` methods with a null reference (Nothing in Visual Basic) instead of a valid instance of the `OpcNodeId` class. > - Issue with too few `HistoryValues` being returned when the server sent no values but a continuation point in one of the responses. > **2.19.1.0 (released on September 1, 2021)** > > **New** > - Introduced new `GetValue` method in `OpcEvent` for subclasses to determine the correct value according to its event type definition and using its property name as the name of the node whose value is to be retrieved. However, the same method can be used to resolve the value using the qualified name syntax as known/supported using the `DataStore.Get` methods. This assures that custom event types no longer need to know the namespace index in any case. > > **Changed** > - **Possibly breaking:** `IOpcReadOnlyNodeDataStore` now requires the implementation of `IOpcNamespaceResolver` as well. > > **Fixed** > - Issue with resolving the corresponding custom `OpcEvent` type/instance for a custom event declared using the expanded node identifier of the event type. > - Issue with hangs observed when connecting to OPC Classic servers. > **2.19.0.0 (released on August 27, 2021)** > > **Breaking:** Clients and servers since version 2.17.0.0 do not access or provide file nodes according to the OPC UA specification. They use a byte array instead of ByteString to read and write file contents. This issue has been fixed in this version. > > **New** > - Enhanced node type and data type resolution to support expanded (that is, resolved) node identifiers as well. > > **Changed** > - **Breaking:** `OpcFileReadMethodNode.FileReadCallback` and `OpcFileReadMethodNode.FileReadExCallback` now return a ByteString instead of an array of bytes. > - **Breaking:** `OpcFileWriteMethodNode.FileWriteCallback` and `OpcFileWriteMethodNode.FileWriteExCallback` now accept a ByteString for the data parameter instead of an array of bytes. > - Parameter of `OpcFilterOperand.OfType` from `value : object` to `typeId : OpcNodeId` to assure that an `OfType` operand is evaluated as expected (that is, using an `OpcNodeId`). > > **Fixed** > - **Breaking:** Regression issue using `OpcFileNode` access using Read and Write operations after enforcing the Foundation's stack to use ByteString for ByteString and `Byte[]` for `Byte[]` instead of using ByteString for `Byte[]`. > - Issue with no history values being returned when the server reports status code `GoodNoData` with a continuation point. > - Issue with infinite history values being returned when the server allows re-using continuation points. ### 2.18 > **2.18.5.0 (released on August 13, 2021)** > > **New** > - Introduced support of encoding-based data type retrieval using `OpcClient.GetDataType` with, for example, `OpcValue.DataTypeId`. > - Enhanced processing of (structured) data type information to support duplicate data type declarations to redirect to data type descriptions where referenced. > - Simplified property node definition without manually adding the node to the children of a parent node. > > **Fixed** > - Regression in version 2.18.4.0 with `OpcException` and `BadServerNotConnected` with enabled `OpcClient.UseDynamic` option while connecting to a server. > - Issues with Siemens OPC UA servers using a custom server interface setup with custom structured data types. This resolution requires the option "enable standard SIMATIC server interface" as well to support the custom server interface setup and its data types used. > **2.18.4.0 (released on August 9, 2021)** > > **New** > - Introduced support of `Expression` compiled delegates in `OpcMethodNodes`. > - Introduced indexer using an `Int32` to address a dedicated `OpcDataField` in an `OpcDataObject`. > - The `OpcClient.SubscriptionsChanged` event is now raised whenever `OpcClient.Subscriptions` are cleared. > - Removed obsolete code no longer supported in .NET 5.0. > - Improved exception handling/message when importing a `UANodeSet`. > > **Fixed** > - Issue with late loaded custom type information after the `OpcClient.Connected` event has been raised. > - Issue with enhanced `byte[]` support which led to no longer working `sbyte[]` support as variable node value (reason of the issue: .NET does not distinguish between signed and unsigned types using pattern matching). > - Issue writing `Byte[]` values to variable nodes, because the Foundation's stack enforces the use of Variant to consume byte arrays as `Byte[]` instead of a ByteString. However, doing so results in wrong type validations writing a variable node using an array of bytes as data type / value. Solved that by considering the subsequent stack code accordingly. > **2.18.3.0 (released on June 28, 2021)** > > **New** > - Enhanced exception details using inner and aggregate exceptions to populate reasons of OPC Classic connectivity issues when using an OPC Classic to OPC UA wrapper server within the same process. > - Introduced additional `OpcNodeIdComparison` options: `IgnoreNamespaceIndex` and `IgnoreNamespaceIndexIgnoreCase`. > > **Changed** > - `OpcClassicDiscoveryClient` now uses `OpcException` to represent all stack related exceptions. > > **Fixed** > - Issues with `OpcServerInfo` if the SDK is used by bundled assemblies. > - Issue when connecting to OPC Classic servers on remote machines. > - Issues with missing nodes while browsing an OPC Classic server with a flat node organization. > - Issue transporting a byte array to a method node, because the Foundation's stack transfers such a value by default as a `ByteString` instead of using it as it is. > **2.18.2.0 (released on June 17, 2021)** > > **New** > - Introduced new `Translate` methods in `OpcServerGlobalization` to provide mechanisms to localize custom resources. > - Introduced support of enum arrays, which is missing in OPC Stack 1.03. > - Introduced `OpcNodeIdComparison` and new `OpcNodeId.Equals` methods to compare node identifiers using different comparison methods. > > **Changed** > - `OpcNodeId` now matches the OPC UA specification and compares node identifiers and namespaces case-sensitively. > > **Fixed** > - Issue with missing preferred locales in `OpcSession` after activating a session. The locales were only internally updated and used. > - Issues with ServerHalted exceptions when accessing properties of an instance of the `OpcServer` class before starting the instance. > **2.18.1.0 (released on June 2, 2021)** > > **New** > - Added additional setter to the `OpcBrowseNode.Degree` property. > - Introduced new `OpcClient.Interfaces` property to configure the communication using OPC Classic interfaces. > - The `OpcClassicDataAccessOptions` class provides options to configure the type of organization to use and whether the server supports the BrowseTo service. > > **Fixed** > - Issue when running on Mono and connecting to an OPC UA server that doesn't send a certificate. > - Issue with missing subscription based notifications after an automatic reconnection. > - Issue with using a byte array in an `OpcValue`, which results in a ByteString encoded byte array upon the underlying stack API. > - Issue with encoding the Value attribute of non-generic `OpcVariableNodes` using an array of ByteString values. > **2.18.0.0 (released on May 26, 2021)** > > **New** > - Improved scenarios where `Byte[]`, ByteString and `ByteString[]` or some of them are used as the data type of a method argument or a variable node. > - Introduced support for `OpcDataTypeInfo.Documentation` used for the `OpcDataTypeNode.Description` attribute. > - Introduced new `OpcReferenceTypes.GetReferenceTypeName(OpcNodeId)` and `GetReferenceType(OpcName)` methods. > - Completely reviewed and enhanced the types `OpcRelativePath` and `OpcRelativePathElement`. > - Introduced support for browse path translation using the `TranslateBrowsePath` service. > - `OpcClient` now supports browse path translation using the new `TranslatePath` and `TranslatePaths` methods. > > **Changed** > - Format of ByteString from Base64 encoding to hex (`X2`) encoded / formatted strings, which matches the Foundation's binary encoded representation of a `ByteString`. > > **Fixed** > - Incorrectly initialized ArrayDimensions and ValueRank attributes of method arguments and variable nodes using `Byte[]`, ByteString or `ByteString[]` or some of them as the data type. > - Incorrectly initialized DataTypeDictionary node regarding its ArrayDimensions and ValueRank attributes after introducing the new explicit ByteString data type. > - An avoidable `NullReferenceException` while initializing encodable data types is no longer thrown. > - Issues with incorrectly determined `OpcArgument` metadata used to define array-based method arguments. > - Issues with reflecting `System.Type` information which is defined by-reference, for example, using an `out` parameter in the delegate of a method node. > - Issues with importing UANodeSets whose references use aliases to address a dedicated node. > - Issue with missing type identifier whenever inspecting fields of data types where the type of the field is an array type. The array type did not provide the type identifier of its element type. > - Issues in applications with third-party components using attribute types which are not loadable. This fixes `TypeLoadExceptions` whenever custom data / event types are inspected. ### 2.17 > **2.17.0.0 (released on May 4, 2021)** > > **New** > - Added support for custom subtypes of the `OpcFileInfo` class. > - Enhanced `OpcMethodContext` with Owner information to gain access to the underlying `OpcServer` instance. > - Enhanced encoding/decoding support for structured data types using their base type information. > - Introduced support of namespaces with null references using `OpcNamespace.Create`. > - Introduced explicit support of the ByteString data type to simplify differentiation between byte array and ByteString values. > > **Fixed** > - Issue with servers supplying null references in their array of namespaces. > - Issue with reset `OpcNode.Description` when using, for example, `OpcDataVariableNode` with a custom data type. > - Issue with uninitialized event nodes used in "off-address-space" scenarios, for example, for "lightweight" events. > - Issue with firewall aware and therefore DNS safe host names used to create a new session using the raw discovered endpoint URL instead. > - Issue with `TypeInitializationException` while testing for Unity in some dynamic assembly load scenarios. > - Issue with `InvalidOperationException` in the Foundation's `BufferManager` whenever a still locked buffer is to be returned without a preceding unlock. > - Issue with unresolved data type information in method node arguments using expanded node identifiers for the data types. > - Issue with unresolved data type encoding in the server's type tree using expanded node identifiers for the data type encoding. > - Issue with comparing expanded node identifiers with the same identifier using different namespaces. > - Issue with querying type information from a custom type whose name is already in use by a different custom type in a different namespace. > - Issue with `NullReferenceExceptions` when trying to translate resources without any localized resource information. > - Issue with missing custom data types which are defined among multiple (dynamic) node managers. > - Issue with default reference type inheritance using the `OpcFolderNodes` default reference type Organizes, which was no longer applied to its direct child nodes after the most recent update of the Foundation's stack. > - Subsequent issue with declaring/accessing variable nodes using ExpandedNodeId/NodeId as DataType. > - Threading issue when starting multiple `OpcServer` instances asynchronously. > - Wrong ArrayDimensions attribute value on the InputArguments and OutputArguments nodes of `OpcMethodNodes`. ### 2.16 > **2.16.1.0 (released on April 21, 2021)** > > **New** > - Enhanced `OpcNominalNodeIdFactory` to apply custom logic to the `OpcName` used to define the `OpcNodeId` created. > > **Fixed** > - Issue with still existing `OpcSubscription` instances in `OpcClient.Subscriptions` although the client has been disconnected. > **2.16.0.0 (released on April 20, 2021)** > > **New** > - Introduced support for custom `OpcFileNode` sources using the new `IOpcFileInfo` interface. > > **Fixed** > - Issue with declaring/accessing variable nodes using `ExpandedNodeId` as DataType. > - Issue with `FileNotFoundExceptions` using some third-party assemblies while dynamic type registration is enabled. ### 2.15 > **2.15.0.0 (released on March 31, 2021)** > > **New** > - Introduced new `Opc.UaFx.Client.OpcSubscription.Client` property to get access to the client which is the owner of a subscription. > - Introduced new `OpcServer.Binding.Addresses` property to define explicit IP addresses of the network interfaces to bind to and listen on. > - Introduced `OpcNodeCollection.TryGet` method to try to look up a node using its node identifier. > - Introduced `OpcNodeManager.GetNode` methods to query nodes using their node identifier or a path which represents a slash (`/`) combined sequence of browse and/or symbolic names to describe the path to the node to determine. > > **Fixed** > - Issue with creating property nodes without a parent node. ### 2.14 > **2.14.0.0 (released on March 4, 2021)** > > **New** > - Introduced new static `OpcName.IsNullOrEmpty` method which ignores the namespace information associated with the `OpcName`. > - Introduced new static `OpcNodeId.IsNullOrEmpty` method which ignores the namespace information associated with the `OpcNodeId`. > - Introduced new `OpcNamespace.GetId(object)` method to determine a new node identifier without knowing which type of value it is. > - Introduced dynamic resolution of data type information when using not registered data types. > - Introduced additional non-generic `OpcData.RegisterType` methods to no longer enforce the use of the generic type parameter. > - Introduced new `OpcDataTypeNode.Create(...)` methods to provide a non-generic way to initialize new `OpcDataTypeNode` instances. > > **Changed** > - Removed duplicate references to `DataTypeNodes` when using the `OpcAddressSpace` class to describe the nodes of the server. > > **Fixed** > - Issue with "malformed" or "TooMany" subscriptions preventing the `OpcClient` from automatically reconnecting after connection loss. > - Issue with inline initialized `OpcDataTypeNodes` using new dynamic resolution of data type information. > - Issue with missing custom enumeration type references in the global data type system. ### 2.13 > **2.13.0.0 (released on March 1, 2021)** > > **New** > - Improved dynamic resolution of the data type attribute supporting expanded node identifiers as well. > - Improved dynamic data type encoding / decoding to support subclassing and cascaded custom structured data types. > - Introduced new `OpcDataTypeIgnoreMemberAttribute` to explicitly exclude a member from being encoded or decoded. > - Introduced new `OpcDataTypeAttribute.NamespaceUri` and `OpcDataTypeAttribute.UseDataTypeDescription` properties to define the target namespace used for the data type dictionary of the data type and to define whether the data type needs to be described in a custom data type dictionary. > - Introduced support of custom target namespaces for custom enumeration types. > - Introduced support for embedded custom data types when using dynamic data exchange using container types like Variant and/or `ExtensionObject`. > > **Fixed** > - Issue with missing target namespace reference in the data type dictionary when using custom data types without target namespace information. ### 2.12 > **2.12.3.0 (released on February 17, 2021)** > > **New** > - Enhanced support of IL2CPP regarding issues with embedded string evaluation. > > **Fixed** > - Issues using default certificate probing paths in Unity using UWP. > - Issue with calling method nodes after introduction of argument localization. > **2.12.2.0 (released on February 15, 2021)** > > **New** > - Implemented localization support for arguments of a method node. > > **Fixed** > - Issue with missing localized information if a client uses the locale of a neutral culture. > - Issue with null references (Nothing in Visual Basic) when reading localizable attributes without localization information. > **2.12.1.0 (released on February 11, 2021)** > > **New** > - Introduced new `OpcNodeExportOptions` to set up the information exported while exporting nodes to a NodeSet. > - `OpcNodeManager.ExportNodes(OpcNodeExportOptions)` method overload to specify custom node export options. > - Introduced new `OpcNodeGlobalization` class to maintain the resources used to localize the attributes of a dedicated node. > - `OpcNode.DisplayNames` and `OpcNode.Descriptions` properties to provide an instance to control the localization on node level per localizable attribute. > > **Changed** > - Bidirectional references between DataTypeDescription, DataTypeEncoding and DataType nodes are now unidirectional (using default export options). > > **Fixed** > - Issue with automatically determined server information using the process related version information including an evaluation of the `ProductVersion` and the `FileVersion`. > - Issue with overridden `OpcNode.SymbolicName` if the node has been imported with a different `SymbolicName` than the DisplayName. > - Issue with no longer multi-line Base64 encoded `DataTypeDictionary` (using default export options). > - Issue with removed `ParentNodeId` attributes in NodeSets (using default export options). > - Issue with re-ordered nodes (using their NodeId) in exported NodeSets. Now they are exported in the order of their definition / implementation. > - Issue with missing supertypes while importing nodes once exported to a NodeSet (because of re-ordered nodes). > **2.12.0.0 (released on February 4, 2021)** > > **New** > - Introduced new `Namespaces` property in `IOpcApplicationInstance` and `OpcApplicationInstance` to provide the namespaces used. > - Introduced new `Namespaces` property in `OpcClient` to reflect the namespaces defined by the server connected to. > - Introduced new `Namespaces` property in `OpcServer` to provide the namespaces used by the node managers of the server to organize the address space. > - Introduced new `Namespaces` property in `OpcContext` to provide the namespaces currently valid within a given context. > - Implemented `IOpcNamespaceResolver` in `OpcNamespaceCollection` and `OpcReadOnlyNamespaceCollection`. > - `Resolve` method in `IOpcNamespaceResolver` to resolve another ("online") namespace using the metadata from an (offline / local) defined namespace. > - `OpcNamespace` now provides a URI whenever `OpcNamespace.Value` is a valid URI. > - Connections to OPC Classic servers through an inline used wrapper server are now secured using the same user identity set up in `OpcClient.Security.UserIdentity`. > - `OpcClient` and `OpcClassicDiscoveryClient` now support the use of a host identity for DCOM authentication. Note: For the `OpcClient`, the `OpcClient.Security.UserIdentity` is used for DCOM authentication as well. > - Introduced new `Scope` property in `OpcNamespace` to describe the context in which the namespace has been created and to which its metadata applies. > - Improved performance initializing `OpcNodes` during the startup of the `OpcServer`. > - Using `OpcNodeManager.ctor(OpcNamespace, ...)` with a namespace which references an explicit namespace index results in an `ArgumentException`, because the server will define the namespace indexes associated with the different namespaces used. > - The `OpcNamespace` instances in the `OpcNodeManager` are now synchronized with the `OpcNamespace` instances in the new `OpcServer.Namespaces` property. Note that until the server is about to start, the instances in `OpcNodeManager.Namespaces` might be exchanged with the instances in the `OpcServer.Namespaces` property. In fact, in methods like `OpcNodeManager.CreateNodes(...)`, all `OpcNodeManager.Namespaces` are already in sync with the `OpcServer.Namespaces`. > > **Changed** > - The `OpcNamespace.Default` namespace now provides the default value and URI used to identify the Foundation's default namespace. > - Removed obsolete methods from `IOpcNamespaceResolver` and all its implementations in `OpcClient`, `OpcServer`, `OpcContext` and `OpcNodeManager`. > - `OpcClient.State` no longer transitions (using the reconnect mechanism activated by default) when calling, for example, `ReadNode` while the `OpcClient` is about to re-establish a broken connection. > - In case of a broken connection, the `OpcClient` tries (by default) to re-establish the connection and re-use the previously used session. If this works, the `OpcClient` will raise the `Reconnected` event as before. If the client has been forced to create a new session (for example, upon timeout of the previous session), the `OpcClient` will now raise the `Connected` event instead of the `Reconnected` event to provide a way to distinguish these conditions in user code. > - Comparison in `OpcNodeId` and `OpcNamespace` to provide results typically used by .NET APIs when comparing to a null reference (this differs from the implementation used by the Foundation). > > **Fixed** > - Issue with "collapsed" endpoint URLs when discovering a server which returns, for example, `opc.tcp://:4840`. > - Issue with unresolved node identifiers used when manually creating MonitoredItems being added to a subscription. > - Issue with "over-resolved" node identifiers through resolving a node identifier always to a new node identifier instead of overriding namespace information in existing node identifiers. > - Issue in OPC Classic Stack with a growing number of threads (especially in MTA applications) in case of connection loss while communicating with OPC Classic servers. > - Issue with providing custom data types without defining an explicit NamespaceUri in their `DataTypeEncoding`. > - Issue with lost `OpcNamespace` information after inline re-initializing the node identifier of a node whose Foundation node identifier has been changed in the meantime. > - Issue in applications where multiple servers are accessed or a client and server are implemented in the same process; however, all involved namespaces did not match every use case. This has now been solved through no longer inline resolving the namespace of an existing node identifier and `OpcNamespace` instance. If this is desired, the user now has to resolve the namespace on their own. ### 2.11 > **2.11.5.0 (released on December 21, 2020)** > > **New** > - Optimized usage of aliases in exported UA NodeSets (unused ones are now removed from the UA NodeSets generated). > - Removed redundant node information by comparing DisplayName and Description. If both are equal, the Description attribute is no longer exported to the UA NodeSet generated. > - Removed redundant ParentNodeId attribute from the UA NodeSets generated if the parent node is already referenced using the `ReferenceTypeId` of the child node. > > **Fixed** > - Issue with `NullReferenceExceptions` in `OpcServer` when trying to add a new node (through a client) with an unknown / invalid parent node identifier. > - Issue with missing node references (to nodes which are defined within a different node manager) in UA NodeSets when exporting nodes whose node identifier has been implicitly assigned. > - Issue with exporting nodes which refer to each other using the ParentNodeId attribute and an explicit node reference (the `ParentNodeId` is now omitted in such a case if `child.ReferenceTypeId` [the default reference type between parent and child nodes] is the reference to declare in the UA NodeSet). Importing the resulting UA NodeSets led to an address space with multiple references between the nodes (which were defined by the `ParentNodeId` attribute and the references defined). > **2.11.4.0 (released on December 15, 2020)** > > **New** > - Introduced new `OpcContext.Owner` property which refers to an `IOpcApplicationInstance` like `OpcClient` or `OpcServer` the context belongs to (if available). > - Introduced new `OpcException.Context` property which offers an instance of the `OpcContext` class and therefore provides additional context-sensitive information regarding an exception thrown/caught. > > **Fixed** > - Issue using abstract methods as delegate for method nodes (caused by an issue in the .NET Framework using `GetCustomAttribute` extension methods). > **2.11.3.1 (released on November 27, 2020)** > > **Fixed** > - Issue connecting to servers evaluating endpoint URLs using case-sensitive comparison and not supporting `/` terminated URLs. > **2.11.3.0 (released on November 23, 2020)** > > **New** > - Added missing `OpcEventDataSetItem.ClientID` property. > - Added missing code documentation of `OpcSecurityPolicy`, `OpcSecurityMode` and `OpcSecurityAlgorithm`. > - Introduced new `PreferredLocales` property to `OpcContext`, `OpcOperationContext` and `OpcSession`. > - Introduced new `OpcNode.Read/WriteDisplayNameCallback` property. > - Introduced new `OpcServer.GetSession(sessionId)` method to query a specific session using its session identifier. > - Introduced new `OpcServer.Globalization` property to provide a more advanced way to localize data and information. > > **Changed** > - Used data type in `OpcNode.Read/WriteDescriptionCallback` property from `String` to `OpcText`. > - `OpcDataChangeDataSetItem.ClientID` from `Int32` to `Int64` to match the used type in `OpcMonitoredItem.ClientID`. > > **Fixed** > - Issue with missing `OpcNotification.Data` using `OpcNotification.GetDataChanges()` without accessing `OpcNotification.Data` before. > - Issue with type initialization in `OpcClient` using Unity with IL2CPP, which results in a different type initialization order. > **2.11.2.0 (released on November 10, 2020)** > > **New** > - Experimental `OpcNodeManager.ExportNodes` method to generate `OpcNodeSet` instances from the address space defined by a node manager. Use the method where required and send us feedback in case of any issues or desired enhancements. > > **Fixed** > - Issue that could lead to a hang in `OpcClient.Dispose()` when a subscription was active. > - Possibility of exceptions in `OpcClient.Dispose` and `OpcServer.Dispose`. > - Issue validating license information using IL2CPP and .NET Standard 2.0 as scripting backend in Unity. > - Issue which prevented use of an existing `SynchronizationContext` to process notifications in the same context a subscription was created from. > - Issue adding nodes with additional node references (references were not added to the address space). > **2.11.1.0 (released on November 5, 2020)** > > **New** > - The `OpcServer` is now able to get stopped while it is in the suspended state. > - Property to configure the `TimestampsToReturn` for all requests using `OpcClient.Services.ReadNodesHistory.TimestampsToReturn`. > - Property to query the `ApplicationUri` contained in the subject alternate name extension of certificates using the `OpcCertificateInfo.ApplicationUri` property. > - Property `OpcClientSecurity.AutoUpgradeEndpointPolicy` to enable endpoint selection using a match (default) and next-best technique to determine an endpoint which at least satisfies the policy configured. > > **Changed** > - The constructor of `OpcCertificateJudgementEventArgs` no longer verifies if the specified certificates are a null reference (Nothing in Visual Basic), because some servers might supply no certificate data for endpoints with the policy `None` (mode and algorithm). > > **Fixed** > - Issue with no longer stored last notifications in subscriptions / MonitoredItems if they are not (or no longer) created for the current session. > - Issue with missing or faulty security policies after restarting the `OpcServer`. > **2.11.0.0 (released on October 6, 2020)** > > **New** > - Introduced method `OpcServer.Suspend()` to change the server's state to `Suspended`. > - Introduced method `OpcServer.Resume()` to change the server's state back to `Started`. > - Enumeration members `Suspending` and `Suspended` in `OpcServerState`. > - Enhanced `OpcSession.Close` to no longer only discard session related diagnostic data. Instead, this method now really closes the session. > - Added missing code documentation to subscription related types in the Client namespace. > > **Changed** > - `OpcSession.Close` closes the session and invalidates the session-related identifier. > - `OpcClient` methods validate the connection state using an `OpcException` (with `BadServerNotConnected`) instead of using an `InvalidOperationException`. > - Default `QueueSize` of `OpcMonitoredItem` created using `OpcClient.SubscribeEvent`(s) from `int.MaxValue` to `uint.MaxValue` to enforce that the server uses the maximum queue size supported for event notifications (which was initially intended with the wrong `int.MaxValue`). > - Renamed `OpcMonitoredItemStatus.DataItemQueueSize` to `QueueSize` to match the naming used in `OpcMonitoredItem` (which defines the requested size while the status gives the revised size). > - Returned type of `OpcMonitoredItemStatus.Id` from `Int32` to `Int64` to cover the underlying non-CLS compliant `UInt32` of the Foundation's stack. > - Adopted recently reviewed API of `OpcMonitoredItem` to `OpcMonitoredItemStatus` and reworked `OpcMonitoredItemStatus.AutoFlushCache` to `QueueMode` (as in `OpcMonitoredItem`). > > **Fixed** > - Wrong status code used for communication errors (`BadNotConnected` -> `BadCommunicationError`). > - The `OpcClient` connected to a fallback/unsecure endpoint if a preset `SecurityPolicy` is not supported by a server. > - Issue with not applied `OpcSubscription.TimestampsToReturn` without changing the MonitoredItems of a subscription. > - Typos in `RegisterNode`(s) code documentation. ### 2.10 > **2.10.0.3 (released on September 11, 2020)** > > **Fixed** > - Issue connecting to OPC Classic servers. > **2.10.0.2 (released on September 9, 2020)** > > **Fixed** > - Issue with comparing `OpcNodeIds` using a byte array as node identifier value. > **2.10.0.1 (released on July 15, 2020)** > > **New** > - Updated description in NuGet. > **2.10.0.0 (released on July 14, 2020)** > > **New** > - Enabled auto-initialization features of nodes added using the `AddNodes` service. This results in the same behavior as used when adding a node within a custom node manager. > - Enhanced `OpcCertificateManager.SaveCertificate` method to determine format of certificate using the file extension of the specified `filePath` parameter. > - Introduced `OpcValueRange.Of` methods to dynamically determine the corresponding `OpcValueRange` for a specific type of data. > - Non-generic `OpcAnalogItemNodes` can now define the corresponding `OpcValueRanges` for the `InstrumentRange` and `EngineeringUnitRange` on their own as well (using the DataType attribute). > - Added support to encode/decode `System.Decimal` (not supported by OPC UA 1.03) using `System.Double`. This applies to fields in data structures. > - `ProductUri` property in `OpcClient` and `OpcServer` to simplify the configuration of it. > - Added automatic initialization of ProductUri information in client and server applications. > - Introduced use/support of an existing `SynchronizationContext` to process notifications in the same context a subscription was created from. > - Improved developer experience in GUI applications (like Windows Forms) regarding correct multi-threading in GUI applications to handle received notifications. > - Introduced `OpcNode.UpdateChanges` methods to notify about changes on behalf of a node (and its children). > - Added missing documentation to different types. > > **Changed** > - `OpcNode.OnAfterApplyChanges` and `OpcNode.OnBeforeApplyChanges` use `OpcNodeChangesEventArgs` instead of `EventArgs`. > - `OpcNode.AfterApplyChanges` and `OpcNode.BeforeApplyChanges` pass `OpcNodeChangesEventArgs` instead of `EventArgs` to event handlers. > > **Fixed** > - Issue writing an analog item node which is offered by a custom node manager without providing an `InstrumentalRange` to validate values written to the node. > - Issue with only once updated `SourceTimestamp` in `OpcValues` (if there was no `SourceTimestamp` explicitly defined) written to the variable node. > - Issue in `OpcNodeHistorian` if a NodeSet imported node with enabled historizing is attached to a new `OpcNodeHistorian` while the node is missing `HistoryConfiguration` and/or `AggregateConfiguration` nodes. > - Issue linking assembly in C++ CLR projects using C++/CLI, which results in C2686. > - Issue with `NullReferenceExceptions` using .NET Core 3.1 while receiving event notification data. > - Issue with not expanded node identifiers in namespace index one (reserved for the core/application namespace). ## 2.0–2.9 (2017–2020) ### 2.9 > **2.9.2.1 (released on May 8, 2020)** > > **Fixed** > - Issue reading a structured data type which uses an array as a field while `OpcClient.UseDynamic` is `true`. > **2.9.2.0 (released on May 6, 2020)** > > **New** > - Added additional constructor overloads to `OpcArgument` to support the use of an `OpcDataType` enumeration value, the identifier of a data type and custom array dimensions as well. > - Added support for n-dimensional (that is, multi-dimensional) arrays of structured data types. > - Added support for n-dimensional variable nodes (this includes the new `ArrayDimensions` property on `OpcVariableNode` as well). > - Added support of null references as field values for fields using a reference type as the type of value. > - Added support of the `ObjectType` NodeClass in calls to the add nodes service. > - Added support of the `VariableType` NodeClass in calls to the add nodes service. > > **Fixed** > - Issue with automatic definition of the `ValueRank` of variable nodes in case of n-dimensional custom structured types. > - Issues in the stack to support n-dimensional custom structured types. > - Issue loading `UANodeSets` with extended values for AccessLevel and UserAccessLevel in UAVariable entries (belongs to stack 1.04). > - Issue with `NullReferenceExceptions` in `OpcDataTypeInfo.BaseType` in case of data types defined in a NodeSet using `UATypeDefinitions` without any field. > - Issue with `NullReferenceExceptions` if an encoding-independent data type (that is, an enum) is defined in the address space. This issue belongs to the server API only. > - Issue with wrongly determined ValueRank in case of `System.Byte`[], because it was matched with the ByteString by the foundation stack. > **2.9.1.0 (released on April 22, 2020)** > > **Fixed** > - Issue which led to duplicate browsed references between parent/child nodes imported using a NodeSet. > - Issues with newer versions of `System.ServiceModel.Primitives`. Rolled back dependency to version 4.5.3 in all target frameworks. > - Issues with subsequent evaluation licenses used for bundle licensing (client and server). > - Issue with wrongly determined ValueRank in case of `System.Byte`[], because it was matched with the ByteString by the foundation stack. > - Issue with result of `OpcNamespace.Get(int, Uri)` which resulted in an `OpcNamespace.Value` which did not express the `Uri.OriginalString` as defined by the `namespaceUri` parameter. > - Issue with cascaded custom data types if they do not define a custom NamespaceUri in their `DataTypeEncoding`. This issue belongs to the server API only. > - Issue with not applied BrowseName in `AddNodes` in case of type `NodeClasses`. This issue belongs to the server API only. > - Issues with type `NodeClasses` regarding wrong `AddNode` command validation. This issue belongs to the server API only. > **2.9.0.0 (released on April 1, 2020)** > > **New** > - Unified product licensing which no longer differs between frameworks. > - All Licenser classes now offer different `FailIf` and `ThrowIf` methods to verify the used license on demand by user code. Use `FailIf` methods in your DEBUG configurations and use `ThrowIf` methods in your RELEASE configurations to protect yourself from the unlicensed use of the SDK. > - Added new `GetNodeType(...)` methods to `OpcClient` (only for event node types). > - Added new `GetNodeTypeSystem(...)` methods to `OpcClient` (only for event node types). > - Added new `GetNodeType(...)` methods to `OpcNodeSet`. > - Added new `GetNodeTypeSystem(...)` method to `OpcNodeSet`. > - `OpcMethodNode` now supports custom defined input and output arguments when using `IOpcMethodCommand`. > - Added new `GetNodeType(...)` methods and `GetNodeTypeSystem()` method to `OpcNodeSet`. > - `OpcNode` now inherits the `OpcNode.Namespace` to its child nodes (if they use the default namespace determined by their `OpcNode.Id`). > - Introduced new specializations of `OpcTypeNodeInfo`: `OpcObjectTypeNodeInfo` and `OpcVariableTypeNodeInfo` (subclassing `OpcTypeNodeInfo`). > - Improved experience while debugging and inspecting the properties of `OpcNodeInfo` instances (and its subclasses). > - Browsing now supports reading additional attributes besides the attributes supported by the browse services. > - `OpcNodeInfo` now implements `IOpcNodeInfo` to provide a more fluent use of node instances independent from their source. > - Additional configurable services in `OpcClientServices`: Browse and `ReadNodes`. > - Significantly improved performance when constructing event filters. > - `IOpcNodeInfo` now defines the additional methods: `AttributeValue(...)`, `Child(...)` and `Children()`. > - Unlimited browse, read and write operations upon automatic request partitioning (`OpcClient`). > - `OpcClient.CertificateJudgement` event to handle certificate issues after a connection has been established and certificate information has been successfully validated first. > - `OpcModel` representing the model information in NodeSets. > - `OpcMemberSwitch.Conditions` property to inform about the condition under which a switch is evaluated. > - Direct support of .NET Core 3.1 as one of our target frameworks. > - Implemented `ReplaceNode` method in `OpcNodeManager` to replace an existing node recursively in nodes, notifiers and MonitoredItems. > - Added additional metadata properties (`LastModified` and `Name`) to `OpcNodeSet`. > - A general implementation of the `IOpcMethodCommand` interface using callbacks: `OpcMethodDelegateCommand`. > - Added missing documentation to collection and some other types. > - `OpcNodeSetManager.ImplementNodeCallback` to implement nodes just using a simple callback method. > - `OpcData.GetNodeId` now supports array types as well. > - Added encoding information in the address space of the server (internal). > - Generic implementation of `IOpcMethodCommand` for delegates: `OpcMethodDelegateCommand`. > - Support of `System.Object` and `System.Object`[] for encoding / decoding data types. > - Support of serialization / deserialization attributes defined in `System.Runtime.Serialization` on data types. > - `OpcDataTypeMembersAttribute` to filter members which shall be encoded / decoded on data types. > - `OpcDictionary` as a bare and not by default available data type to transport dictionaries using OPC UA. > - It is no longer necessary to link the name or identifier of custom defined root nodes returned by `OpcNodeManager.CreateNodes(...)` manually to the default namespace of the custom `NodeManager`. > - Respecting the order of fields as they are declared within their inheritance hierarchy to always define the fields of the base data type first. > - Added new `GetDataType(...)` methods to `OpcClient`. > - Added new `GetDataType(...)` methods to `OpcNodeSet`. > - `IOpcNodeInfo` now defines the methods `Child(...)` and `Children()` to query the child nodes of a node instance. > - Implemented new `OpcNamespaceCollection`. > - `OpcNodeSet.Namespaces` property to provide the namespaces referred to in a NodeSet. > - `IOpcMethodCommand` to define/use custom command instances instead of being forced to define an explicit delegate. > - `OpcMethodCommands` class to provide predefined commands such as NotImplemented. > - Enhanced `OpcMethodNode` to support `IOpcMethodCommand` instances as well as invocation target instead of using a delegate. > - Enhanced generic `OpcDataTypeNode` class to no longer support only enumeration types. The class now supports the use of class and struct types as well and maps them to OPC UA structures. > - Introduced new abstract and non-generic `OpcDataTypeNode` class. > - Static `OpcContext.Empty` property to define an empty context instance where required and supported. > - Implemented `IOpcNamespaceResolver` in `OpcContext` to resolve namespaces of `OpcNodeId` instances. > - `OpcTypeSystem` class which acts as the new base class of the existing `OpcDataTypeSystem` and the new `OpcNodeTypeSystem` classes. > - `OpcDataTypeDictionary.Documentation` property. > - `OpcNodeSetManager` class which enables simple hosting of `OpcNodeSets` using `OpcNodeSetManager.Create(...)`. > - Protected virtual methods `OpcNodeManager.ImportNodes()` and `OpcNodeManager.ImplementNode(IOpcNode)`. > - Unified and simplified DataType resolution especially using non-built-in data types for variable and property nodes. This affects the nodes: `OpcDataItemNode`, `OpcDataItemNode`, `OpcAnalogItemNode`, `OpcAnalogItemNode`, `OpcDataVariableNode`, `OpcDataVariableNode`, `OpcConditionVariableNode`, `OpcConditionVariableNode`, `OpcPropertyNode`, `OpcPropertyNode` and `OpcVariableNode`. > > **Changed** > - License codes used prior to version 2.9 no longer work. Customers will receive new license keys working in all frameworks supported. > - `OpcAttributeWriteAccess` is now based on `UInt32`. > - The default value of `OpcAutomatism.AlwaysParseStringIdentifiers` is now `false`. As a result, the value is no longer parsed automatically when the constructor `OpcNodeId(string)` is called. For more details, see `OpcAutomatism.AlwaysParseStringIdentifiers`. > - [Client SDK] Moved the `OpcBrowseNode` class from namespace `Opc.UaFx.Client` to namespace `Opc.UaFx`. > - [Client SDK] Moved the `OpcBrowseNodeDegree` enumeration from namespace `Opc.UaFx.Client` to namespace `Opc.UaFx`. > - [Client SDK] `IOpcBrowseService` and `OpcBrowseRequest` now use the classes `OpcViewDescription` and `OpcBrowseNode` instead of the Foundation classes `ViewDescription` and `BrowseDescription`. > - Moved `OpcReadOnlyNamespaceCollection` from namespace `Opc.UaFx.Server` to namespace `Opc.UaFx`. > - Changed the default value of the DataType attribute of `OpcDataTypeDictionaryNode` from Byte to ByteString to match the definition of the specification. > - Renamed `Description` property of `IOpcDataTypeInfo`, `OpcDataTypeInfo` and `OpcDataFieldInfo` to `Documentation` to match the definition of the OPC UA specification. > - `OpcEncoding.All(...)` now constructs the `OpcEncoding.Id` using the default BrowseNames for the different encoding types. > - `OpcNamespace.ToString()` now always returns a string which just represents the `OpcNamespace.Value` and `OpcNamespace.Index` (if not zero). > - `OpcNodeSet.GetDataTypeSystem()` now provides an `OpcDataTypeSystem` instance which uses the typical BrowseName for the type of encoding used by the type system. > - Removed method `IOpcTypeProvider.GetType(OpcEncoding)`, because encoding information only applies to data types. > - `OpcTypeCategory.EventType` and `OpcTypeCategory.ReferenceType` have been removed. > > **Fixed** > - Issues with validating outdated certificates or certificates which violate some policy regarding generally valid certificates. Such certificates can now be handled by the `CertificateValidationFailed` event. > - Issue with the automatic application configuration if the `AssemblyTitleAttribute` of the entry assembly is not present or defines `string.Empty` as assembly title. > - Issue with variable node values changing their value using different complex data types (expressed using `ExtensionObject` as the data type of the node). > - Wrong `EncodingMask` if there is more than one optional field declared in a data type. > - Wrong interpretation in `OpcArgument.IsArray` and `OpcArgumentInfo.IsArray`. > - An `OpcVariableNode.Timestamp` initially defined is no longer reset during address space creation. > - Issues with wrongly determined default value ranks and default data type identifiers using `OpcDataTypes.GetValueRank(..)` and `OpcDataTypes.GetNodeId(...)`. > - Issue with DataTypeDictionary nodes which do not define any DataTypeDescription nodes while constructing the `DataTypeSystem` using `OpcClient.GetDataTypeSystem()`. > - Issues when decoding structured data using the new `Opc.UaFx.Bit`. > - Issue using `OpcNodeId.UriIdentifier(...)` if the `OpcNodeId.Value` is not of the type `System.String`. > - `OpcNamespace` now preserves the original string used to define the `OpcNamespace` without any subsequent changes (by the `System.Uri` class) as the value of the `OpcNamespace.Value` property, so that it always returns the same `System.String` value that was used to define the instance. > - Some conditions under which a newly created `OpcNode` without a name could not be renamed later. ### 2.8 > **2.8.3.1 (released on January 24, 2020)** > > **Fixed** > - Issue with no longer working subscription handlers after a long running reconnection attempt succeeded. > - Issue with disposed socket in disposed `TcpMessageSocket` used in a request header representing the last request sent to the server to which the connection got lost. > **2.8.3.0 (released on January 16, 2020)** > > **New** > - Support of `OpcExceptions` in delegates used to define method nodes. This enables the definition of bad results without the need to manually change the result of the method call using the `OpcMethodContext` parameter. > - Added support for additional access levels (`StatusWrite` and `TimestampWrite`). > - Added missing documentation to `OpcAccessLevel`, `OpcVariableNode.AccessLevel` and `OpcVariableNode.UserAccessLevel`. > - Added support to disconnect and abort a pending reconnect attempt on `OpcClient`. > - Changes to improve the experience with UWP applications regarding the use of the native tool chain. > > **Changed** > - Reviewed `OpcClient.State` changes to detect a lost connection to the server. > - `OpcClient.State` now changes automatically only to `Disconnected` (during a running request) if `ReconnectTimeout` is greater than zero (reconnection is manually handled). > > **Fixed** > - Issue with not applied status (code) information passed to one of the constructors defined by `OpcValue`. > - Issue with `TypeDictionaries` which do not offer NamespaceUri information. > **2.8.2.1 (released on December 13, 2019)** > > **Fixed** > - Issue with parallel subscription publishing while calling a method node in `OpcClient`. > - Issue with not updated `OpcVariableNode.Value` if there is no custom `WriteVariableValueCallback` associated with a variable node. > - Issue with conditions upon which the `OpcClientKeepAlive.Interval` is not applied to the current session. > **2.8.2.0 (released on November 6, 2019)** > > **New** > - Introduced new `Opc.UaFx.Bit` as a .NET-based representation of the foundation-defined "Bit" value type for which no concrete implementation exists so far. > > **Changed** > - Explicitly encoded information known as the `EncodingMask` of a structured data type is now handled using the new `Opc.UaFx.Bit` type instead of `System.Boolean`. > > **Fixed** > - Issue with mixed-structured data types using leading Boolean values followed by additional non-Boolean values which sometimes resulted in wrongly encoded data streams. > - Issue connecting to OPC Classic servers using OPC Watch without a custom application certificate. > - Issue in `OpcServerInfo.FromProcess(...)` if the `ProductVersion` of the `FileVersionInfo` of the `ProcessModule` of `Process.MainModule` provides a version string which not only consists of numbers and dots like `1.2.3.4-preview`. > **2.8.1.3 (released on October 24, 2019)** > > **Fixed** > - Issue with exchanging structured data types without using the upcoming metadata support. > **2.8.1.2 (released on October 23, 2019)** > > **Changed** > - Adjusted `iconUrl` and `licenseUrl` information in NuGet packages upon their deprecation. > > **Fixed** > - OPC Classic support no longer worked ("An internal error occurred as a result of a programming or configuration error") because the OPC Classic client could no longer find its embedded resources. > - Issue with wrong interpretation of `Int32` as return type of method nodes. > **2.8.1.1 (released on October 11, 2019)** > > **New** > - Implemented support for method parameters using `System.Object` which are transported as OPC UA variant values. > > **Fixed** > - Issues with disregarded method parameters of the type `System.Object`. > - Issue with reading large file nodes (representing files whose content exceeds the `MaxByteStringLength`). > **2.8.1.0 (released on September 25, 2019)** > > **New** > - Implemented `RegisterNodes` and `UnregisterNodes` methods on the `OpcClient` that allow registering nodes on the OPC UA server for the current session for possibly faster access. > - Enabled the OPC Classic API in the .NET Standard target to support the use of the API in .NET Core applications running on Windows. > - Implemented `OpcDataObject.HasField(name)` and `OpcDataObject.TryGetField(name, out field)`. > - Improved performance by excluding foundation defined data type dictionaries while querying the data type system of the server. > - Introduced new `OpcClient.UseDynamic` property and changed default value of `OpcAutomatism.UseDynamic` to the value `false` to improve the performance while connecting without the need of the knowledge of data types. > - Implemented support for servers which do not support range-based reads to query the data type dictionary. > > **Fixed** > - Crash caused by an exception in `Socket.Shutdown()` that was not caught. > > **Changed** > - `OpcAutomatism.UseDynamic` property default value is now `false`. Change its value or the `OpcClient.UseDynamic` to `true` to enable use of `OpcDataObject`. > **2.8.0.0 (released on September 18, 2019)** > > **New** > - Introduced a whole set of new classes to support the definition, consumption and reflection of custom data types in client applications. > - Introduced new `OpcNodeSet` class to provide a file, string or stream based source to offer data type system information from a `UANodeSet`. > - Implemented new `OpcClient.NodeSet` property to assign an instance of the `OpcNodeSet` class which is to be used to query data type system information instead of querying the server's data type system. > - Implemented new `OpcClient.GetDataTypeSystem()` method which determines the data type system which is used by the client to resolve data type information. > - Introduced new `OpcAutomatism.UseDynamicTypeRegistration` property to control the automatic type reflection used by client and server applications to determine the different data and event types declared. > - Introduced new `OpcAutomatism.UseDynamic` property to control the dynamic type resolution while consuming custom typed but not explicitly declared data types in client applications. > - Introduced new `OpcNodeValue` class, `OpcAttributeValue` and `IOpcNodeAttribute` with `IOpcNodeDescriptor` in conjunction with `OpcNodeValuePair` to declare "node-bound" values. > - Enhanced `OpcClient` class with new `ReadNodeValue` and `WriteNodeValue` methods to read and write "node-bound" values. > - Improved exception handling to preserve StackTrace information from user code down to foundation and communication layer. > - Implemented new `OpcClient.KeepAlive` property and the corresponding `OpcClientKeepAlive` class to control and monitor the keep alive tasks executed against the server connected to. > - Implemented dynamic type conversion in `OpcValue.As()`. > - Added new `AsValue()` method to `OpcValue` to provide a generic definition of the value using the new `OpcValue` class. > - `OpcNamespace` now provides the namespace string / URI using the new `OpcNamespace.Value` property. > - Default transport limits increased: `DefaultMaxByteStringLength` from 64 KB to 5 MB and `DefaultMaxMessageSize` from 1 MB to 10 MB. > - Solved inline handled exceptions in `XmlSerializer` during startup. > - Improved exception handling and tracing during data encoding and decoding (see `OpcTypes.EncodingFailed` and `OpcTypes.DecodingFailed`). > - Support for tracing all encoding operations using the new `OpcEncodingStackFrame` and `OpcEncodingStackTrace` classes. > - Introduced decoding and encoding related tracing support using the new `OpcEncodingStackFrame` and `OpcEncodingStackTrace` classes. > - Added `int ResolveIndex(string namespaceValue)` and `string ResolveValue(int namespaceIndex)` to `IOpcNamespaceResolver`. > - `OpcClient` now provides service methods to simplify calls to `CallMethod` using the new generic methods `CallAction` and `CallFunc`. > - Added additional overloads to `OpcBrowseNode` to support `OpcNodeIds` to refer to specific types of references. > - `OpcNodeInfo` now provides additional overloads of `Children(...)` and `Parents(...)` accepting an `OpcReferenceType` value. > - `OpcResult` now provides the root result with `GetBaseResult()`. > - `OpcEventNode.EventTypeId` is now writable using an added setter. > - Introduced `OpcEventTypeAttribute` to define client-side declared custom event types used to handle event notification data in client applications. > - Corrected wrongly used status code while decoding in the foundation stack (before: `BadEncodingError`, now: `BadDecodingError`). > - Added missing `SourceType` property to `Opc.Ua.Schema.Binary.FieldType`. > - Added missing `BaseType` property to `Opc.Ua.Schema.Binary.BaseType`. > > **Fixed** > - Wrongly used variable when configuring `Opc.UaFx.Client.OpcSubscription.LifetimeCount`. > - Issues during serialization of `OpcException` objects. > > **Changed** > - `OpcDataTypeAttribute` is now applicable on classes and structures. > - Unified `OpcNodeManager.NamespaceIndexes` and `OpcNodeManager.NamespaceUris` into new `OpcNodeManager.Namespaces`. > - Renamed `IOpcReadOnlyDataStore` to `IOpcReadOnlyNodeDataStore`. > - `IOpcNamespaceResolver` methods `Uri Resolve(int namespaceIndex)` and `int Resolve(Uri namespaceUri)` are now obsolete. ### 2.7 > **2.7.5.1 (released on August 15, 2019)** > > **New** > - Added use of `OpcNominalNodeIdFactory` (via `OpcNodeId.Factory`) to resolve OPC Classic tag names using the OPC Classic server specific tag separator. > > **Fixed** > - Issue with multiple times serialized exception information which caused `SerializationExceptions` instead of the exception itself. > **2.7.5.0 (released on August 13, 2019)** > > **New** > - Improved API documentation: `IOpcNode`, `IOpcNodeInfo` and `OpcNode`. > - Stack change to assure that a node manager lock is held as long as MonitoredItems are created, modified or deleted. > - Updated `System.ServiceModel.Primitives` to version 4.5.3. Version 4.5.x of `System.Private.ServiceModel` fixed a bug that caused the `System.Private.ServiceModel.dll` not to be copied for .NET Core applications when publishing for Windows (`win-xxx`). > > **Fixed** > - Issues with compiling using the .NET Native tool chain. > - Issues with multiplied subscription notifications and events after reconnecting to the server. > - Issues with inline parsed `OpcNodeIds` when creating an `OpcNodeId` using a string identifier. > - Issue with wrongly used base address and security policies in `OpcDiscoveryServer`. > - Issue with re-created `OpcMonitoredItem` instances which additionally resulted in the issue that comparing `OpcMonitoredItem` instances no longer worked. > > **Changed** > - `OpcMonitoredItem.AutoFlushCache` has been replaced with the new `OpcMonitoredItem.QueueMode` property to better express the mechanism used when the notification data item queue of a MonitoredItem overflows. > **2.7.4.0 (released on June 7, 2019)** > > **New** > - Domain name resolution used while validating client / server certificates now uses fallback mechanisms if there is no DNS server configured in the operating system. > - Re-implemented explicit use of `OperationTimeout` when using HTTPS (which is no longer part of the foundation stack). > - Implemented `MonitoredItemsCreated`, `MonitoredItemsModified` and `MonitoredItemsDeleted` events in `OpcNodeManager`. > > **Fixed** > - `SocketExceptions` on macOS while validating certificate domains using domain name resolution although there is no (available) DNS server configured in the operating system. > > **Changed** > - Changed some `int`-based properties in `OpcMonitoredItem`, `OpcServiceCounter`, `OpcSessionDiagnostics` and `OpcServerDiagnostics` to `long` as their property type to assure CLS compliance while accessing the unsigned API of the foundation stack. > **2.7.3.1 (released on May 23, 2019)** > > **New** > - [Client SDK] Added support for target framework .NET Framework 4.6. > > **Fixed** > - Issues with connecting to a server using HTTPS on macOS and Linux, which results in the `OpcException` "An unrecognized response was received from the server." > **2.7.3.0 (released on May 17, 2019)** > > **New** > - Replaced local `X509Certificate2` instance activation by using `OpcCertificateManager.QueryInstance` to load certificate information. This enables custom `X509Certificate2` creation using an `EventHandler`. > - Introduced new `OpcCertificateStores.PathProbings` property to enable custom probing mechanism to determine the certificate store paths to use by default. > - Improved user experience regarding different (smaller) issues using subscriptions and MonitoredItems (especially in automatically reconnecting clients). > - Introduced additional `AddMonitoredItem(...)` overloads on `OpcSubscription`. > > **Fixed** > - Issue with connecting to servers using HTTPS, which results in the `OpcException` "An unrecognized response was received from the server." > > **Changed** > - Reviewed implementation of `OpcMonitoredItem` and `OpcSubscription`: Changed some `int`-based properties to use `long` as the property type to support underlying `uint` properties used by the foundation stack in a `CLSCompliant` way. > **2.7.2.0 (released on May 10, 2019)** > > **New** > - Support of `TypeDefinition` information when browsing instance nodes through new `OpcInstanceNodeInfo` class. > - Added `Socket` property to the `OpcSession` class to identify the socket identity information for the used local and remote endpoints. > - Changed product icon of NuGet package. > - [Client SDK] Enabled support for IL2CPP in Unity projects. This addresses some overflow exceptions reported while IL2CPP has been executed. > > **Fixed** > - Issues when browsing more than one reference type at once which resulted in an `ArgumentOutOfRangeException`. > - Issues with sometimes outdated subscription and MonitoredItem information when the client automatically reconnects to the server after the connection got lost. > - Issue with sometimes missing client and subscription based notification events, for example the `NotificationReceived` event has been missed on `OpcClient`. > **2.7.1.1 (released on April 29, 2019)** > > **New** > - Updated the package information (`ProjectUrl` and `LicenseUrl`). > **2.7.1.0 (released on March 25, 2019)** > > **New** > - Implemented rejection of requested node identifiers using unknown namespace index values (in `AddNodes` service, `BadNodeIdInvalid`). > - Implemented use of node (identifier) specific node manager to assure that a node being added is not added to the nodes of the node manager of the parent node if the new node refers to the namespace maintained by a different node manager. > - Node access and write flags are now applied recursively when adding nodes by a client. > > **Fixed** > - Issue with bad node rejected in case of a client defined node identifier using `AddNodes`. > - Issues with custom node attributes used to set up the write and access attributes of nodes added by clients. > - Corrected not nicely formed namespace URI of default node manager (removed unnecessary `/`). > - Issue with wrongly wrapped .NET array types using `OpcValue` instances. > - Issue with wrongly wrapped UA FX array types using `OpcValue` instances. > - Issue with missing DataType information if an `OpcVariableNode` (non-generic) is initialized with an initial value using its constructor followed by a change of its `DataType` property to the appropriate type. Result: The `DataType` property value was not accepted. > **2.7.0.2 (released on March 15, 2019)** > > **Fixed** > - Wrongly used addressing of unmanaged memory (using OPC Classic) which especially can fail in processes using large address awareness (see `LARGEADDRESSAWARE`). > **2.7.0.1 (released on March 15, 2019)** > > **Fixed** > - Issue with locales which are supported by the OPC Classic servers but not by the operating system. > - Issue with addressing OPC Classic servers running on a 64-bit system. > **2.7.0.0 (released on March 14, 2019)** > > **New** > - Completely reworked `AddNode` support in `OpcClient` including a whole new set of `OpcAddNode` command types like `OpcAddFolderNode`, `OpcAddObjectNode`, `OpcAddDataVariableNode`, `OpcAddAnalogItemNode` and some more. > - First time full support of `AddNode` service calls in `OpcServer` accepting every supported type definition to add a new node into the address space. > - Completely reworked `DeleteNode`, `AddReference` and `DeleteReference` support in `OpcClient` including a whole new definition of the `OpcDeleteNode`, `OpcAddReference` and `OpcDeleteReference` command. > - Reworked support of `DeleteNode`, `AddReference` and `DeleteReference` service calls in `OpcServer` using additional request validations. > - Introduced new `OpcAddNodeResult` class which provides a specialization of the `OpcResult` class to provide the used NodeId and the command instance from which the result of an `AddNode` service call originates. > - `OpcNodeManager` now provides virtual methods called when adding or deleting a node to / from the address space of the manager (through the `AddNode` and `DeleteNode` services). > - Improved exception details when using the services `AddNodes`, `DeleteNodes`, `AddReferences` and `DeleteReferences`. > - `OpcServerIdentity` constructor overloads accept a string value as password. > - `OpcServer` events: `RequestProcessing`, `RequestValidating`, `RequestValidated` and `RequestProcessed` to pre- and post-process client requests and the sent responses. > - `OpcException` always provides `Source`, `StackTrace`, `Data` and `HelpLink` information where available and no longer skips them in case of a different source exception. > - `IOpcNode.Child(...)` method to retrieve an `IOpcNode` child instance using the name (that is, the BrowseName) of the child node. > - Additional `OpcServerIdentity.ChangePassword(string)` method overloads. > - Additional `OpcUserNameAcl.AddEntry(...)` method overloads to define a custom `OpcServerIdentity`. > - Enabled subclassing of `OpcResult` using custom types. > > **Changed** > - Removed `OpcServerIdentity.Password` property, because there is no need to publish the internally stored password information and it is not a good practice to provide references to an array through properties. > - Removed `OpcTransformUserPasswordDelegate` delegate. > - Replaced `OpcUserNameAcl.PasswordTransform` with virtual `Matches` and `TransformPassword` methods in `OpcServerIdentity`. > > **Fixed** > - Issue when writing built-in structured values like `OpcEngineeringUnitInfo` or `OpcValueRange` using `OpcClient.WriteNode`. > - Issue when disconnecting / stopping the client / server which led to a crash if there was still at least one connect attempt pending. > - Issue with `StackOverflowExceptions` when changing the `OpcServer.Configuration` instance. ### 2.6 > **2.6.0.0 (released on February 20, 2019)** > > **New** > - Implemented OPC Classic support in `OpcClient` just using an address like `opc.com://(:)//` (only in .NET Framework). > - Implemented new `OpcClassicInterface`, `OpcClassicInterfaces` and `OpcClassicInterfaceCollection` classes and `OpcClassicInterfaceCategory` enumeration (only in .NET Framework). > - Implemented new `OpcClassicApplicationDescription`, `OpcClassicApplicationDescriptionCollection`, `OpcClassicEndpointDescription` and `OpcClassicEndpointDescriptionCollection` classes (only in .NET Framework). > - Implemented OPC Classic discovery using the new `OpcClassicDiscoveryClient` class, which uses `OpcEnum.exe` (a COM application provided by the OPC Classic runtime environment) (only in .NET Framework). > - Enhanced existing `OpcDataChangeFilter` to support the configuration of the trigger, `DeadbandType` and `DeadbandValue`. Using the `Trigger` property it is possible to monitor items using the `SourceTimestamp` as well. > - Implemented additional `OpcClient.SubscribeDataChange` overloads and additional `OpcDataSubscribeDataChange` constructor overloads accepting a value of the `OpcDataChangeTrigger` enumeration. > - A predefined `ApplicationName` is now used as the `SubjectName` of the certificate when (automatically) creating a new certificate used by client or server applications. > - Implemented generic `OpcApplicationInstance` class implementing `IOpcApplicationInstance`. > - `OpcClient` and `OpcServerBase` use the new `OpcApplicationInstance` class as their common base class. > - Implemented generic `OpcSecurity` base class for the security settings of client and server applications. > - `OpcClient` derives from the `OpcApplicationInstance` class. > - `OpcServer` derives from the `OpcApplicationInstance` class through its base class `OpcServerBase`. > - Centralized application configuration (within the SDK) of client and server application instances using `OpcApplicationInstance`. > - Implemented generic `OpcTransport` configuration class and its use in `IOpcApplicationInstance`. > - Implemented generic `OpcSecurity` configuration class and its use in `IOpcApplicationInstance`. > - Added `Security` and `Transport` properties to `IOpcApplicationInstance`. > - Added `CertificateValidationFailed` event to `IOpcApplicationInstance`. > - `OpcSecurityPolicyCollection` now implements a public constructor. > > **Changed** > - Removed `OpcClientTransport` class (replaced by new `OpcTransport` class). > - Removed `OpcServerTransport` class (replaced by new `OpcTransport` class). > - The default server information provided by `OpcServerBase` now prefers a predefined `ApplicationName`. > - `OpcSecurityPolicyCollection` no longer provides a constructor with an `OpcServerBase` instance. The corresponding `Owner` property has been removed as well. ### 2.5 > **2.5.7.0 (released on February 6, 2019)** > > **New** > - `OpcClient.WriteNode` now directly accepts `null` as the value without the need of a new `OpcValue` instance. > - The `OpcServer` class provides new constructor overloads which use the default address `opc.tcp` + `localhost` + `4840` (the default port). > - The whole node tree can now be created inline using new constructors of `OpcObjectNode` and `OpcFolderNode` to specify their children directly when they are created. > - Ensured that read/write operations on attributes are canceled if a custom read/write callback returns a "bad" result. In case of a "good" result the processing of the read/write operation continues. > - API whose signature only accepts `nodeId : string` to identify a node now parses the specified string value inline to ensure a more fluent usage of the SDK API. > > **Changed** > - The application certificate is no longer stored in `.\CertificateStores\Trusted`, now it is stored (by default) in `.\CertificateStores\App` to improve startup performance when searching for the application certificate. > - Changed use of `LinkTime` to `LastWriteTime` of the assembly when determining `OpcServerInfo` from an assembly. > > **Fixed** > - Issue with not applied initial value when using the `OpcDataVariableNode(parent, name, value)` constructor. > - Included missed value checks (like `BadTypeMismatch`) in cases where the Value attribute is written. > **2.5.6.0 (released on October 19, 2018 [Client SDK], February 6, 2019 [Client+Server SDK])** > > **New** > - Added enhanced Android linking support when linking SDK+User for additional APIs. > - Enhanced default certificate store directory to first try to use the local directory (if it is writable), then `CommonApplicationData` and then `ApplicationData`. > - Additional support of .NET Framework 4.7.1 as the target framework to no longer refer to 12 additional system assemblies caused by .NET Standard references in .NET Framework 4.7.1. See the Microsoft article [Targeting .NET Framework 4.7.1 copies extra files to your bin directory](https://github.com/Microsoft/dotnet/blob/master/releases/net471/KnownIssues/514195-Targeting%20.NET%20Framework%204.7.1%20copies%20extra%20files%20to%20your%20bin%20directory.md). > > **Fixed** > - Issue when checking if a certificate store already contains a certificate. The store always returned `true`. > - Solved issues when browsing in an Android SDK+User linked environment. > **2.5.5.0 (released on October 11, 2018 [Client SDK], February 6, 2019 [Client+Server SDK])** > > **New** > - Extracted API for exclusive client development from OPC UA Advanced. > - `CertificateRequested` event on `OpcClient` and `OpcServerBase` to query an alternative certificate if an existing application instance certificate could not be found or can't be used. This event can also be used to determine the reason why a new certificate is required. The client can also use it to notify or ask its user. > - If `.\CertificateStores\` (the default directory for certificates) is not writable, the path `$(AppData)\OPC Foundation\CertificateStores\` is instead used as the default directory to maintain certificates. > - Increased default lifetime of a certificate from 12 months (1 year) to 600 months (50 years). > - Reduced default key size from 2048 to 1024 to support older certificates. > - Less assembly size and fewer dependencies through reorganization of the internal licensing mechanism for .NET Standard. > - In case of failed socket binding, an exception is no longer caught nor thrown as a generic exception. Instead, it is forwarded to the caller. > - `Binding` property on `OpcServer`, which provides an instance of the new `OpcServerBinding` class. > - `OpcServerBinding` (`OpcServerBase.Binding` property) defines the address scope the server binds to. By default it will bind (as before) to any `IPv4` and to any `IPv6` address using the specified port number. > - The low-level read/write operations of node managers now provide `OpcNodeAccessTokens` with operation result information. > - Added documentation for `OpcSubscription`, `OpcMonitoredItem`, `OpcMonitoredItemEventArgs`, `OpcMonitoredItemEventHandler` and more regarding subscriptions. > > **Changed** > - Changed default `MinimumCertificateKeySize` from 2048 to 1024 to support lower key sizes used by older certificates. > - When changing the application certificate of a client or server instance using the `Certificate` property, the store path type of the application certificate store changes to `System`. To use the store path type `Directory`, you have to change the store path type manually and have to ensure that the certificate can be found in the application certificate store after changing the `Certificate` property. > > **Fixed** > - `OpcServer.Security.AutoAcceptUntrustedCertificates` when using secured endpoint policies did not auto-accept untrusted certificates. > - Problem when dynamically determining the start time of the node history to read count-based. > - Issue with so far not comparable MonitoredItem and session instances. > - Issue when writing a node value using `OpcValue` encapsulated raw values. > - Wrong use of `AutoAcceptUntrustedCertificates` in server application instances. > - Issue with rejected path of the application certificate store when manually changing the application certificate. > - Incorrectly used start time when reading historical values without explicitly specifying a start time. > **2.5.4.0 (released on August 27, 2018)** > > **New** > - Implemented support for automatic history creation in `OpcNodeHistorian` through client-written values (`AutoUpdateHistory` property). > - `OpcNodeHistorian` now differentiates node changes and now logs only changes of the Value attribute. > - Improved code documentation on server-side subscription and MonitoredItem API. > - `Server.OpcSubscription` and `Server.OpcMonitoredItem` instances are now comparable through caching existing instances. > > **Fixed** > - `OpcVariableNode.IsHistorizing` is no longer reset after `OpcNodeManager.CreateNodes` has been called. > - Issue with writing to variable nodes with undefined DataType attribute (did not work and an exception was thrown). > > **Changed** > - `OpcNode.BeforeApplyChanges` and `OpcNode.AfterApplyChanges` are now only raised if changes are pending (see `OpcNode.HasPendingChanges`). > **2.5.3.0 (released on August 21, 2018)** > > **New** > - Implemented automatic value arrangement after reading a node value (server-side) using the encoding and value range requested by the client. > - New `OpcClientTransport` class accessible via `OpcClient.Transport` to set up transport options like timeouts and limits. > - New `OpcServerTransport` class accessible via `OpcServer.Transport` to set up transport options like timeouts and limits. > > **Fixed** > - Issue with incorrectly used certificate data source when validating an X509 identity token. > **2.5.2.5 (released on August 7, 2018)** > > **New** > - Removed NuGet dependencies enforced (in .NET Standard) to reference in user projects. > - Simplified content of `*.deps.json` (in .NET Standard). > **2.5.2.4 (released on July 31, 2018)** > > **Fixed** > - Issue with reporting global events using `OpcServer` and `OpcNodeManager` instances. > > **New** > - Implemented support of null `OpcName` instances when using `OpcNominalNodeIdFactory`. > - `OpcContext` now always provides an appropriate `OpcNodeIdFactory` instance, at least the global instance defined by `OpcNodeId.Factory`. > **2.5.2.3 (released on July 25, 2018)** > > **New** > - NuGet updated. > **2.5.2.2 (released on July 23, 2018)** > > **Fixed** > - `InvalidCastException` when the assembly was loaded with `Assembly.LoadFrom()`. > **2.5.2.1 (released on July 13, 2018)** > > **Fixed** > - `DllNotFoundException` when trying to use specific types before creating an `OpcClient` or `OpcServer`. > **2.5.2.0 (released on July 6, 2018)** > > **New** > - Activated licensing support for .NET Standard, which also covers .NET Core applications through the netstandard2.0 assembly. > **2.5.1.1 (released on July 3, 2018)** > > **New** > - Renewed the evaluation license to provide a new license period. > **2.5.1.0 (released on June 15, 2018)** > > **New** > - MIME type support in `OpcFileNode` and `OpcFileInfo`. > - Improved performance when accessing `OpcContext` references in `OpcNodes` (internally). > - Improved performance / memory usage when accessing the children of an `OpcNode` (internally). > - Removed inline and by default always prepared history configuration nodes for all variable nodes. Instead, they are now created on demand. > - Removed internal cross-references and use of heavy OnXy callbacks defined by the Foundation. Instead, we now use a provider pattern. > - Introduced `IOpcNodeInfo` to no longer create temporary `OpcNode` instances. This improves performance and memory usage. > - `IOpcNodeInfo` is used in scenarios where a reference to the origin node is not required. This also reduces the amount of memory required to process internal node operations / evaluations. > - Introduced cache for custom data types to no longer repeatedly reflect their attributes to improve performance. > - Exceptions which are thrown during the execution of `CreateNodes(...)` are now passed to the source where `OpcServer.Start` has been called. > > **Changed** > - Changed `IsNodeAccessible(..., IOpcNode node)` to `IsNodeAccessible(..., IOpcNodeInfo node)`. > **2.5.0.3 (released on May 24, 2018)** > > **Fixed** > - Issue with not working external references when using multiple node managers which share the same custom node as the root of the nodes provided. > **2.5.0.2 (released on May 23, 2018)** > > **Fixed** > - Issue with missing nodes when using multiple node managers referencing the same system node. > **2.5.0.1 (released on May 16, 2018)** > > **Fixed** > - `NullReferenceException` in `OpcMethodNode` when using a predefined node as the parent of the method node. > - `OpcDataVariableNode` no longer displayed in the server's address space when using the constructor `(parent : IOpcNode, name : OpcName)`. > > **Changed** > - Downgraded sample projects to C# language version 6.0 to ensure that the samples will compile in older versions of Visual Studio. > **2.5.0.0 (released on May 10, 2018)** > > **New** > - Added support for creating nodes using a custom node identifier. > - Streamlined constructor overloads in all node classes. > - Added a lot of so far missing code documentation on node classes. > - Implemented for each property of a node a corresponding `XyNode` property which provides the reference to the property node that represents the value of the so far available `Xy` properties. > - Implemented support for lazy initialization of nodes which allows defining the `Xy` property values to be set up while they are applied to their property nodes on server startup. > - Completely reviewed implementation of `OpcNodeId` and `OpcNamespace`. Partially re-implemented both classes to ensure a maximum of compatibility to Foundation-defined node identifier standards including the features provided by this SDK. > - The `OpcNodeId` now supports identifiers using byte arrays, GUIDs and unsigned integers. > - The `OpcNodeId` now expresses the type of identifier value in its string representations generated using `OpcNodeId.ToString`. > - The `OpcNodeId` now supports UTF-8 encoded special characters in a URL-formatted node identifier. > - The `OpcNodeId` now supports parsing Foundation-formatted node identifiers. > - The `OpcNodeId` now provides additional properties like `OriginalString` and `OriginalFormat`. > - Reworked `OpcName` implementation to no longer combine the BrowseName, DisplayName and `SymbolicName` into one instance / class. > - `IOpcNode`, `OpcNode` and `OpcNodeInfo` now provide direct properties for the DisplayName (and `SymbolicName`) of a node. > - `OpcNodeInfo` now supports the children and parent browsing using a combination of the `OpcNodeCategory` enum members. > - `OpcClient.SubscribeEventRaise` methods and `OpcSubscribeEventRaise` now support an `OpcEventFilter` instance for event filtering. > - Reviewed existing API regarding UA Alarm + Events and adjusted it for a more fluent / intuitive interface including some changes to use lazy initialization to improve performance. > - Reworked `OpcEventRaiseEventArgs` to define the `Event` property for `EventNode` snapshot information using event raw data. > - Added `MonitoredItem` property to `OpcDataChangeEventArgs` and `OpcEventRaiseEventArgs`. > - Added events `DataChangedReceived` and `EventRaiseReceived` to `OpcSubscription`. > - Implemented `OpcEventType` enumeration and `OpcEventTypes` to simplify access to the different event types supported. > - Implemented different state machine and state / transition variable nodes. > - Implemented `DialogRequested` event in `OpcClient` to provide a simple way to process `OpcDialogConditionNode` instances. > - Implemented support for Foundation-specified event types. These are: `OpcConditionNode`, `OpcAcknowledgeableConditionNode`, `OpcDialogConditionNode`, `OpcAlarmConditionNode`, `OpcDiscreteAlarmNode`, `OpcLimitAlarmNode`, `OpcOffNormalAlarmNode`, `OpcSystemOffNormalAlarmNode`, `OpcTripAlarmNode`, `OpcExclusiveLimitAlarmNode`, `OpcNonExclusiveLimitAlarmNode`, `OpcExclusiveDeviationAlarmNode`, `OpcExclusiveLevelAlarmNode`, `OpcExclusiveRateOfChangeAlarmNode`, `OpcNonExclusiveDeviationAlarmNode`, `OpcNonExclusiveLevelAlarmNode` and `OpcNonExclusiveRateOfChangeAlarmNode`. > > **Fixed** > - Corrected the wrong name of method `GetOutpuArguments` to `GetOutputArguments` in the `OpcMethodNodeInfo` class. > - Issue with `DBNull` values used if there is no default value for an argument specified in method nodes. > > **Changed** > - Corrected misspelled members. > - Streamlined API through additional descriptive parts in class and delegate names. In general, changed the naming of `Data` to `DataSet`, `DataItem` to `DataSetItem` and `EventRaise` to `Event`. > - `OpcNodeId.ToString` now formats by default using the `OpcNodeIdFormat.Foundation` format. > - Order of subscription events from MonitoredItem → Client → Subscription to MonitoredItem → Subscription → Client, to ensure a more logical event order using bubbling. > - Renamed `OpcMonitoredItem.ReceivedDataChange` to `OpcMonitoredItem.DataChangeReceived`. > - Renamed `OpcMonitoredItem.ReceivedEventRaise` to `OpcMonitoredItem.EventRaiseReceived`. > > **Breaking changes due to renamings** > - `OpcSubscribeEventRaise` -> `OpcSubscribeEvent` > - `OpcDataChangeEventArgs` -> `OpcDataChangeReceivedEventArgs` > - `OpcDataChangeEventHandler` -> `OpcDataChangeReceivedEventHandler` > - `OpcEventRaiseEventArgs` -> `OpcEventReceivedEventArgs` > - `OpcEventRaiseEventHandler` -> `OpcEventReceivedEventHandler` > - `OpcNotificationEventArgs` -> `OpcNotificationReceivedEventArgs` > - `OpcNotificationEventHandler` -> `OpcNotificationReceivedEventHandler` > - `OpcDataChangeCallback` -> `OpcDataChangeReceivedCallback` > - `OpcEventRaiseCallback` -> `OpcEventReceivedCallback` > - `IOpcNotificationData` -> `IOpcNotificationDataSet` > - `OpcNotificationData` -> `OpcNotificationDataSet` > - `OpcNotificationDataCollection` -> `OpcNotificationDataSetCollection` > - `OpcNotificationDataReadOnlyCollection` -> `OpcNotificationDataSetReadOnlyCollection` > - `OpcNotificationDataItem` -> `OpcNotificationDataSetItem` > - `OpcNotificationDataItemCollection` -> `OpcNotificationDataSetItemCollection` > - `OpcNotificationDataItemReadOnlyCollection` -> `OpcNotificationDataSetItemReadOnlyCollection` > - `OpcDataChange` -> `OpcDataChangeSet` > - `OpcDataChangeItem` -> `OpcDataChangeSetItem` > - `OpcEventRaise` -> `OpcEventDataSet` > - `OpcEventRaiseItem` -> `OpcEventDataSetItem` > - `OpcMonitoredItem` > - `.EventRaiseReceived` -> `EventReceived` > - `.LastEventRaise` -> `LastEvent` > - `.OnEventRaiseReceived` -> `OnEventReceived` > - `OpcSubscription` > - `.EventRaiseReceived` -> `EventReceived` > - `.ReceivedEventRaiseCallback` -> `ReceivedEventCallback` > - `.OnEventRaiseReceived` -> `OnEventReceived` > - `OpcClient` > - `.EventRaiseReceived` -> `EventReceived` > - `.OnEventRaiseReceived` -> `OnEventReceived` > - `.SubscribeEventRaise` -> `SubscribeEvent` ### 2.3 > **2.3.2.0 (released on March 13, 2018)** > > **Fixed** > - Issue with wrong use of `DebuggerDisplayAttribute` in `OpcVariableNode` and `OpcNodeInfo`. > - Issue with reading / writing custom DataType attribute values on `OpcVariableNodes`. > > **Changed** > - `OpcVariableNode` defined as an abstract base class. > - Removed multiple local Foundation node references to reduce memory usage. > > **New** > - Enhanced implementation of `OpcVariableNode` especially for enumeration types. > - Implemented new nodes `OpcTypeNode` and `OpcDataTypeNode`. The `OpcDataTypeNode` does support the definition of custom enumeration types. > - Implemented enhanced support to simplify browsing of enumerated data types. The new `OpcTypeNodeInfo.GetEnumMembers()` method provides all the information available on an enumerated type (also see the new `OpcTypeNodeInfo.IsEnum` property). > **2.3.1.1 (released on February 26, 2018)** > > **Fixed** > - Issue with loading the `OpcApplicationConfiguration` from a file, because of a required DataContract attribute on the `OpcApplicationConfiguration` class which was not required in older SDK versions. > > **New** > - Implemented additional constructor overloads in `OpcEngineeringUnitInfo` to simplify initialization of a specific unit. > - Implemented `ToString` overloads in `OpcEngineeringUnitInfo` and `OpcValueRange`. > - `CommonCode` property in `OpcEngineeringUnitInfo` and static `GetCommonCode(int unitId)` method. > - `DefaultNamespaceUri` in `OpcEngineeringUnitInfo` is used when using a constructor without an explicit namespace parameter. This is not the case when using the default constructor. > **2.3.1.0 (released on February 22, 2018)** > > **Attention** > - Starting with this version, a reference to the NuGet package `Portable.BouncyCastle` (at least version 1.8.1.3) or the `BouncyCastle.Crypto` assembly (at least version 1.8.1.146) is required. > - Using a server address with the scheme `https` requires references to the NuGet packages `Microsoft.AspNetCore.Server.Kestrel` (1.1.3) and `Microsoft.AspNetCore.Server.Kestrel.Https` (1.1.3). > > **New** > - Implemented the Range data type as `OpcValueRange`. > - Implemented the `EUInformation` data type as `OpcEngineeringUnitInfo`. > - Implemented new node type `AnalogItemType` as `OpcAnalogItemNode`. > - Support of `DataValues` using the data types Range and `EUInformation`. > - Advanced support for browsing nodes using the AnalogItemType definition through the new `OpcAnalogItemNodeInfo`. > - Updated to target framework .NET Framework 4.6. > **2.3.0.0 (released on February 13, 2018)** > > **New** > - Updated to Foundation stack 1.03.351.0. > - Implemented new security option for client / server to define additional certificate validation rules (see `OpcClient/OpcServer.Security.CertificateValidationRules`). > > **Changed** > - The SDK no longer supports Windows-based authentication using the WinLogon API for OPC UA server authentication. > - Application certificates are now created using SHA256 (the default defined by the Foundation). This does not influence any running code. This change will only have an effect when a new certificate is generated. ### 2.2 > **2.2.2.0 (released on December 11, 2017)** > > **New** > - Enhanced filter construction using operator overloads to get a more natural API. > - Introduced `OpcText` to represent localized human-readable string values. > > **Fixed** > - Issue with missing use of configured `OperationTimeout` using `OpcClient.Connect()` while discovering the server endpoints. > > **Changed** > - Simplified `OpcValue.ToString` implementation to just provide `null` for null references or the `Value.ToString()`. > **2.2.1.0 (released on September 6, 2017)** > > **New** > - Added support for incomplete certificate chains when the peer provides a certificate which is signed by an unknown issuer. This is, for example, the case when trying to connect to a Siemens SIMOTION. > - Enhanced support for failed certificate validations using the `CertificateValidationFailed` events in the `OpcClient` and `OpcServer` classes. > **2.2.0.0 (released on September 1, 2017)** > > - **New:** Added the `GetReferenceType` method to resolve the corresponding `OpcReferenceType` for a given `OpcNodeId` of the type of reference. > - **Changed:** Removed special handling of the attribute DataType in `OpcNodeInfo.Attribute()`. This means that there is no longer an `OpcDataType` value provided. Instead, the data type dependent `OpcNodeId` is provided. > - **New:** Implemented basic support for object nodes and extended support for variable nodes, also implemented generic support for type nodes (including `ObjectTypes`, `VariableTypes` and `DataTypes`) while browsing nodes. > - **New:** Using the `OpcVariableNodeInfo`, `OpcObjectNodeInfo` and `OpcTypeNodeInfo`, it is now possible to browse the address space using additional information about the nodes provided. This also includes, for example, the type information of a variable node including all its type-specific metadata including super- and subtypes. > - **New:** Prepared the SDK for use under .NET Standard and .NET Core 2.0. > - **New:** Introduced the `LicenseInfo` property on all Licenser classes to provide some information about the license conditions used. ### 2.1 > **2.1.0.0 (released on August 1, 2017)** > > **New** > - Updated to OPC UA Foundation stack 1.3.342.0. ### 2.0 > **2.0.1.1 (released on June 7, 2017)** > > **New** > - `RegisterAddress` / `UnregisterAddress` methods and new `Addresses` method to maintain the different base addresses of an `OpcServerBase` instance. > > **Fixed** > - Corrected the wrong naming of `IsNodeAccessable` in `OpcNodeManager` to `IsNodeAccessible`. > - Issue with malformed node namespaces using a namespace URI just built from a scheme if `OpcNamespace.ToString()` is called (`FormatException`). > - Issue with wrong implicit interpretation of status codes as result information. > **2.0.1.0 (released on May 24, 2017)** > > **New** > - Added many more details to the message of an `OpcException` and to the description of an `OpcStatus` / `OpcResult` instance to better indicate the source / reason / outcome of an operation. > **2.0.0.0 (released on May 21, 2017)** > > - **New:** Changed the assembly version to 2.0.0.0. > - **New:** Implemented `OpcCertificateSettings` to configure an application instance certificate which can be created through the `OpcCertificateManager`. > - **Fixed:** Issue with wrongly configured application certificates using a store path in cases when the certificate cannot be located under such a path. > - **Fixed:** Issue with wrongly stored user name and password pair in the `UserName` ACL (access control list) that led to unsuccessful user authentication. > - **Fixed:** Issue when creating an `OpcNodeId` using the `string` + `int32` pair, where the `int32` was not used for the namespace index of the new NodeId. > - **Fixed:** Issue with `OpcServerBase.Certificate` and `OpcClient.Certificate` if the certificate is not stored in the `ApplicationStore` of the certificate stores. > - **New:** Introduced `OpcClientCertificateStores` (available through `OpcClient.CertificateStores`) and `OpcServerCertificateStores` (available through `OpcServerBase.CertificateStores`) to provide a fluent API for client and server to manage and maintain their certificate stores. > - **New:** Introduced `OpcClientServices` (available through `OpcClient.Services`) to provide a service-based API to set up the different services used by the client. > - **Removed:** `OpcValue.SourceLabel` and `OpcValue.ServerLabel`. This also includes that the `OpcValueLabel` class no longer exists. The provided properties are now provided directly via the `OpcValue` class. Just make use of the `OpcValue.ServerXy` and `OpcValue.SourceXy` properties. > - **New:** `IOpcWriteNodesService` now supports an automatic discovery of which value the server expects for the `SourceTimestamp` of an `OpcValue`. The automatic determination can be disabled by setting an explicit `OpcTimestampSource` using the `IOpcWriteNodesService.TimestampSource` property. Note: The `IOpcWriteNodesService` instance can be accessed using the `OpcClient.Services.WriteNodes` property. > - **New:** Removed usage of the obsolete `ResolveNodeId` method and implemented the new `Resolve` method on the `OpcNodeId` instead to determine the fully qualified node identifier using the server's namespaces array on demand. This now supports the node access using the fully qualified node identifier without the need to know the index of the dedicated node namespace. > - **New:** Implemented an additional overload of the `UpdateCertificate` method to manually define whether a certificate is to be created if a certificate is missing or not valid. So far this was only possible by using the static `AutoCreateCertificate` property. > - **New:** Implemented the new properties `OpcClient.Certificate` (to directly define a custom client certificate) and `OpcClient.Security` (to set up client security options within one class). > - **Changed:** Renamed property `OpcSecurity.Policies` to `OpcSecurity.EndpointPolicies` to match the `OpcClientSecurity.EndpointPolicy` model. > - **Changed:** Defined the default value of `OpcCertificateManager.AutoCreateCertificate` as `true`. > - **New:** Implemented the new properties in `Opc.UaFx.Server.OpcSecurity`: `AutoAcceptUntrustedCertificates` and `AutoCreateCertificate`. > - **New:** Implemented the new `OpcServer.Certificate` property to match the same API model as the `OpcClient` implements. > - **Changed:** Behavior used to select an endpoint to connect to, so that it is no longer negotiable if there is an explicit endpoint policy defined. > - **Changed:** Default of `AutoAcceptUntrustedCertificates` in `SecurityConfiguration` to `true`. > - **New:** Implemented support for a `DefaultNodeManager`. This is either the first manager in the list of managers defined or the internally defined default node manager which defines the namespace as `/nodes/`. You can now also define just a callback method that provides the nodes for the default node manager's address space. > - **Moved:** `OpcClient.PreferredPolicy` property to `OpcClient.Security.EndpointPolicy`. > - **Moved:** `OpcClient.UseDomainChecks` property to `OpcClient.Security.VerifyServersCertificateDomains` and changed its default value to `false`. > - **Moved:** `OpcClient.UserIdentity` property to `OpcClient.Security.UserIdentity` and changed its type from the Foundation type `IUserIdentity` to `OpcUserIdentity`. > - **Moved:** `OpcClient.UseOnlySecureEndpoints` property to `OpcClient.Security.UseOnlySecureEndpoints` and changed its default value to `false`. > - **Removed:** Obsolete `OpcClient.UseAutoNodeIdResolution` property. > - **New:** Reworked / reviewed `OpcIdentity` derivatives and defined the `OpcCertificateIdentity`, `OpcWindowsIdentity`, `OpcServerIdentity` and `OpcClientIdentity` as new derivatives of `OpcUserIdentity` (so far they just used the `OpcIdentity` as their base class). Also changed their construction behavior to simplify the process of identity creation on client and server side. > - **Fixed:** `OpcRequestType.Call` has been defined as `OpcRequestType.Cancel` so far. This led to a nonfunctional use of the `OpcRequestType.Call`, because it has then been used like the `OpcRequestType.Cancel`. > - **Removed:** `OpcCertificateManager.AutoCreateCertificate` property, because it is now used per instance using `OpcClient.Security.AutoCreateCertificate` or `OpcServer.Security.AutoCreateCertificate`. Also these properties are by default set to the value `true`. > - **Removed:** `OpcServer.Security.Owner` property to reduce redundant reference information and simplify the API. > - **Renamed:** `Server.OpcSecurity` to `Server.OpcServerSecurity`. > - **Renamed:** `OpcServerSecurity.Anonymous` to `OpcServerSecurity.AnonymousAcl`. > - **Renamed:** `OpcServerSecurity.Certificate` to `OpcServerSecurity.CertificateAcl`. > - **Renamed:** `OpcServerSecurity.IssuedToken` to `OpcServerSecurity.IssuedTokenAcl`. > - **Renamed:** `OpcServerSecurity.UserName` to `OpcServerSecurity.UserNameAcl`. > - **Renamed:** `OpcClient.PreferredLocales` to `OpcClient.Locales`. > - **Renamed:** `OpcClient.ReceivedNotification` to `OpcClient.NotificationReceived`. > - **Renamed:** `OpcClient.OnReceivedNotification` to `OpcClient.OnNotificationReceived`. > - **Renamed:** `OpcSubscription.ReceivedNotification` to `OpcSubscription.NotificationReceived`. > - **Renamed:** `OpcSubscription.OnReceivedNotification` to `OpcSubscription.OnNotificationReceived`. > - **Moved:** `OpcNodeCommand` from `Opc.UaFx.Client` to `Opc.UaFx.Services`. > - **Moved:** `OpcNodeAttributeCommand` from `Opc.UaFx.Client` to `Opc.UaFx.Services`. > - **Renamed:** `OpcNodeCommand` to `OpcNodeServiceCommand`. > - **Renamed:** `OpcNodeAttributeCommand` to `OpcNodeAttributeServiceCommand`. > - **Renamed:** `OpcStatusCode` members with `Bad`, `Good` and `Uncertain` prefixes, as the OPC Foundation uses them to divide status codes into these three categories. > - **New:** Implemented additional `ReadNode` overloads to define a numeric node identifier together with a namespace index and attribute to read. > - **New:** Implemented new `ReadNodes` methods to read multiple nodes using a specific attribute. ## 1.0–1.6 (2015–2017) ### 1.6 > **1.6.5.2 (released on February 7, 2017)** > > **Changed** > - Removed implicit interpretation of a numeric node identifier encoded as a string. > **1.6.5.1 (released on December 8, 2016)** > > **New** > - Implemented enhanced timeout handling for read history requests produced by the `OpcClient`. This is necessary to give the server additional time to collect the historical data if it takes more time than usual and the server provides successive continuation points until the data collection has been completed. > **1.6.5.0 (released on December 7, 2016)** > > **New** > - Enhanced node history navigation in case of a fixed time window (where `StartTime` and `EndTime` are not equal to `MinDate`). Therefore node history values are collected on each page request as long as the server provides a continuation point, either until the server no longer provides a continuation point or until the page has reached its page size. > **1.6.4.0 (released on October 12, 2016)** > > **New** > - Updated the `IOpcNode` interface definition with respect to the current public `OpcNode` API. > - Implemented new method `Children()` : `IEnumerable` in `IOpcNode` to determine physical children in the node tree. > **1.6.3.0 (released on October 6, 2016)** > > - **New:** Implemented the new method `OpcFileMethods.IsFileNode` to determine if a node is accessible in the manner of a FileType. > - **Fixed:** Out-of-memory issue when using `OpcFile.ReadAllText` and `OpcFile.ReadAllLines`. > - **New:** Improved performance of `OpcFile.ReadAllText` to no longer construct the text using the lines of the file; instead it now uses the binary stream of the file. > - **New:** Generally optimized the speed of reading and writing file contents by using the client-configured `MaxByteStringLength`. > - **Fixed:** Issue when browsing nodes containing remote nodes which led to the exception: "Cannot cast an absolute `ExpandedNodeId` to a NodeId. Use `ExpandedNodeId.ToNodeId` instead." > **1.6.2.0 (released on October 4, 2016)** > > - **New:** Implemented the new method `CreateTempCertificate` which is also used in cases where `AutoCreateCertificate` is set to `true` and where the certificate generator utility is not installed. Therefore there is no longer a need to have the certificate generator utility deployed for testing and development besides OPC applications. > - **Fixed:** Issue with opening files for writing: the access mask has been verified in the wrong way. > - **New:** Implemented a new Session Resource Manager to dispose of any session-related resources whenever a session times out or closes. Such a resource is the internal file handle when accessing file nodes via OPC. If the client discards the connection to the server for any reason, the Session Manager now releases all resources acquired by the session. > **1.6.1.0 (released on September 14, 2016)** > > **New** > - Implemented the `OpcNodeManager.Browse` method to support custom browsing in subclassing scenarios. > **1.6.0.0 (released on August 25, 2016)** > > - **New:** Excluded non-value attributes from automatically updating the source label of the value when writing node values. Workarounds to use an explicit `OpcValue` are now obsolete. > - **New:** Introduced the new derivative `OpcBrowseNodeContext` especially for node browsing and reduced the previous `OpcNodeContext` to a more generic implementation for further subclassing. The new `OpcBrowseNodeContext` now also includes the NodeId of the node from which the browsing operation has been originally initiated. > - **New:** Introduced the `OpcValue.As` method to retrieve the represented value as a specific type by converting the value to the type specified by `T`. > - **New:** Implemented the new `OpcResult` class to represent `ServiceResult` instances. > - **New:** Implemented the subclass `OpcMethodContext` of `OpcContext` to determine method call sensitive system information including the method node being called and its target. This also includes storing the outcome of the callback routine invocation. > - **New:** Implemented file system accessibility support for `OpcFileNode` objects from the client point of view. This includes a simple 1:1 API layer implemented by the `OpcFileMethods` class, a `SafeOpcFileHandle` to ensure allocated file handles are freed, the `OpcFile` class to implement an OPC-based `System.IO.File` class-like set of service methods, the `OpcFileInfo` class to implement an OPC-based `System.IO.FileInfo` class-like object and the `OpcFileStream` class to implement an OPC-based `System.IO.FileStream`-like object which is derived from the `System.IO.Stream` class and can therefore be used by all `StreamReader` and `StreamWriter` classes provided by the .NET Framework. > - **New:** Implemented the new `OpcPropertyNode` and `OpcPropertyNode`. > - **Changed:** The type `OpcVariableValue` now requires a generic type parameter for the type of value represented. The `OpcVariableNode` class has been adapted regarding this type parameter. > - **New:** Implemented the new `OpcFileNode` including its child nodes like the method nodes `Open`, `Close`, `GetPosition`, `SetPosition`, `Read` and `Write`. ### 1.5 > **1.5.11.7 (released on July 28, 2016)** > > **Fixed** > - Issue with remote node identifiers in `OpcNodeId`. > - Issue with comparing node identifiers of different types in `OpcNodeId`. > **1.5.11.6 (released on June 17, 2016)** > > **New** > - Implemented the `Child` method on `OpcNodeInfo` to retrieve the successors of a node using its `OpcName`. This includes the BrowseName, DisplayName and `SymbolicName` of a node. > - Implemented the `Parent` method on `OpcNodeInfo` to retrieve the ancestors of a node using its `OpcName`. This includes the BrowseName, DisplayName and `SymbolicName` of a node. > - Implemented the `Children` method on `OpcNodeInfo` to retrieve successors of a node of a specific `OpcNodeCategory`. > - Implemented the `Parents` method on `OpcNodeInfo` to retrieve ancestors of a node of a specific `OpcNodeCategory`. > **1.5.11.5 (released on June 13, 2016)** > > **New** > - Implemented implicit cast operator for `ExpandedNodeIds`. > - Implemented additional `Get` method overload on `OpcNamespace` to retrieve node namespaces using a URI or index. > > **Fixed** > - Issue with `ExpandedNodeIds` in `OpcValues` and simplified the handling of them. > **1.5.11.4 (released on May 30, 2016)** > > **New** > - Minimized lock conditions when reading / writing nodes. > **1.5.11.3 (released on May 2, 2016)** > > **New** > - Renewed the evaluation license to provide a new license period. > **1.5.11.2 (released on April 18, 2016)** > > **Fixed** > - Issue with MonitoredItems when reading the initial value of a node (the server ran into a `NullReferenceException` in case of unfiltered MonitoredItems). > **1.5.11.1 (released on March 31, 2016)** > > **New** > - Implemented the `Changed` event on `OpcStatus`. > > **Fixed** > - Issue with the not synchronized OPC status from SDK to the Foundation stack (on `OpcValue` and `OpcVariableNode`). > **1.5.11.0 (released on March 23, 2016)** > > - **New:** `OpcNamespace` which represents the whole namespace information of a node identifier (namespace index and namespace URI). > - **New:** `IOpcNamespaceResolver` which is implemented by `OpcNodeManager`, `OpcClient` and `OpcServer`. This interface provides late-bound namespace resolution after the `OpcServer` is started or the `OpcClient` is connected. Each `OpcNodeId` whose namespace has been resolved provides the fully qualified URL of the namespace together with the node identifier. > - **New:** `OpcNodeId.Namespace` property to provide the associated `OpcNamespace`. > - **Changed:** Renamed `OpcAttribute.Historizing` to `OpcAttribute.IsHistorizing`. > - **New:** `OpcNode`: Implemented node change tracking through the properties `HasPendingChanges` and `PendingChanges` including the method `IsChangePending`. > - **New:** Implemented history support for `OpcVariableNode` and its subclasses. > - **New:** Enhanced constructor overloads of `OpcStatusCollection` for a much simpler setup of a new instance using `OpcStatusCodes`. > - **New:** HDA methods on the client to read and update node history. > - **New:** HDA interface on the server to provide the required logic to handle historical data access. > - **New:** HDA services: `IOpcReadNodesHistoryService` and `IOpcUpdateNodesHistoryService`. > - **New:** HDA commands: `OpcCreateNodeHistory`, `OpcDeleteNodeHistory`, `OpcDeleteNodeHistoryAtTime`, `OpcDeleteNodeHistoryModified`, `OpcReadNodeHistory`, `OpcReplaceNodeHistory` and `OpcUpdateNodeHistory`. All of them are subclasses of the `OpcNodeHistoryCommand`. > **1.5.10.0 (released on February 3, 2016)** > > **New** > - Added the OPC Watch application to the assembly archive. > **1.5.9.1 (released on January 25, 2016)** > > **Fixed** > - Issue with a wrongly closed and released session although it can be reused in case of a reconnect. > **1.5.9.0 (released on January 21, 2016)** > > - **Fixed:** Possible multithreading issues in the session keep-alive in `OpcClient`. > - **Changed:** The `BreakDetected` event is now raised only if the reconnect timeout equals zero. > - **Fixed:** In case of closing and releasing an OPC client session which has already been disposed of, in some cases it could lead to an undesired reconnect to the server upon an `ObjectDisposedException` thrown by the already disposed client session. > **1.5.8.0 (released on January 18, 2016)** > > **New** > - Updated the licensing logic. > **1.5.7.1 (released on January 14, 2016)** > > **Fixed** > - Issue with the minimum possible `PublishingInterval` in the `OpcSubscription` class. > **1.5.7.0 (released on January 9, 2016)** > > - **Fixed:** Issue with the `NullReferenceException` in `OpcCertificateManager.CreateCertificate` when passing an `applicationUri` as a null reference (Nothing in Visual Basic). > - **Fixed:** Issue with not uniquely generated `OpcNodeIds` for `InputArguments` and `OutputArguments` of `OpcMethodNode` instances. This led to the behavior that only the arguments of the most recently provided `OpcMethodNode` were published when browsing / reading the method argument properties. > - **Changed:** The `OpcNodeId` for `InputArgument` and `OutputArgument` nodes of `OpcMethodNode` instances; for more information, see the entry before. > - **Changed:** The `OpcReadOnlyNodeCollection` class now provides `IOpcNode` instances instead of the internal Foundation `NodeState` instances. > - **New:** An `OpcNodeId` can now be constructed from `OpcName` instances whose `SymbolicName` is a null reference (Nothing in Visual Basic). In this case the BrowseName is used instead of the `SymbolicName`. > - **New:** The `OpcReadNodesRequest` now returns both timestamps (source and server) by default. > - **New:** Implemented new `OpcNodeManager` methods: `AddNode`, `RemoveNode` and `IsNodeAccessable`. > - **Fixed:** Issue with duplicate ACEs (access control entries) some of the time when requesting an ACE which has already been added to an ACL. > **1.5.6.8 (released on December 17, 2015)** > > **Fixed** > - Issue with missed `TimeStamp` update on writing node values. > - Issue with missed `TimeStamp` data on reading node values. > **1.5.6.7 (released on December 17, 2015)** > > **New** > - Implemented the `ChangePassword` method on `OpcServerIdentity` to change the user password after an identity has been created. > - Implemented the protected `SystemContext` property on `OpcNodeManager` to provide an alternative context within which system-internal changes can be performed. > - The `OpcWriteNode` class now automatically sets the source label timestamp when writing a node. > > **Changed** > - The `OpcValueLabel` is now no longer defined as a struct; instead it is now a class. > **1.5.6.6 (released on December 16, 2015)** > > **New** > - Implemented `AddNode` and `RemoveNode` in `OpcNodeManager` to support dynamically providing nodes after `CreateNodes` has been called. > **1.5.6.5 (released on December 10, 2015)** > > **New** > - Added additional session information to `OpcOperationContext` when calling `IsNodeAccessable` on `OpcNodeManager`. > **1.5.6.4 (released on December 9, 2015)** > > **New** > - Implemented the `IsNodeAccessable` method on `OpcNodeManager` to specify in custom code whether a node is accessible within the view. > **1.5.6.3 (released on December 8, 2015)** > > **Fixed** > - Issue with duplicate ACEs when manually adding additional entries on demand. > **1.5.6.2 (released on October 12, 2015)** > > **Fixed** > - Issue with reading and writing `OpcValue` instances and arrays as node values on the client and server sides. > - Issue with anonymous user login on the server side when creating an `OpcSession` object. > > **New** > - Implemented redirection if the string value passed to the constructor (string, int) of the `OpcNodeId` class indicates a numeric identifier. Now an `OpcNodeId` will be initialized with the numeric identifier instead of using the string value. > **1.5.6.1 (released on September 8, 2015)** > > **Fixed** > - Issue with Anonymous and `UserName` ACLs enabled at the same time. > > **New** > - Implemented additional `CreateCertificate` overloads in `OpcCertificateManager`. > **1.5.6.0 (released on September 7, 2015)** > > - **Changed:** Renamed the `BuiltInType` property to `DataType` on `OpcAttributeInfo`. > - **New:** Browsing the DataType attribute now results in a member of the `OpcDataType` enumeration. > - **New:** Implemented `OpcValue` as a surrogate of the `DataValue` class. > - **New:** Implemented the static `CreateCertificate` method on `OpcCertificateManager` to create certificates out of the box. > - **New:** The `OpcStatus` class now provides the new `OpcStatusCode` enumeration as code. > - **New:** Implemented support for `OpcDataTypes`: `ExtensionObject`, `Value` and `Variant`. > - **Changed:** Renamed `DataValue` to `Value` in `OpcDataTypes`. > - **New:** Implemented support to directly start browsing using a method node. > - **Changed:** Moved `OpcDiscoveryClient` to the `Opc.UaFx.Client` namespace. > - **Fixed:** Issue with `NullReferenceException` when noncached nodes are browsed. > - **New:** Implemented support for using a null reference for an application URI to create certificates. > - **New:** Implemented a new abstraction layer for different OPC server types (`OpcServerBase`). > - **New:** Implemented a new OPC server specialization: OPC Discovery Server. > - **Fixed:** Issue in the OPC client with accessing the internal session instance although it has been disposed of. > **1.5.5.3 (released on August 25, 2015)** > > **New** > - Simplified the use of `OpcVariableClass` in read / write callbacks by determining the status and timestamp (if no other has been specified) from the node instance. > **1.5.5.2 (released on August 24, 2015)** > > **Fixed** > - Issue with Anonymous and `UserName` ACLs enabled at the same time. > > **New** > - Removed the `OpcAccessControlMode` member `Default` and replaced its use with `Blacklist`. > **1.5.5.1 (released on August 24, 2015)** > > **Fixed** > - Issue with null DataType in `VariableNodes`. > **1.5.5.0 (released on August 24, 2015)** > > **New** > - Implemented different callback properties to read / write `OpcNode` attributes. > - Implemented protected virtual methods to read / write `OpcNode` attributes. > - Implemented specific callback properties to read / write `OpcVariableNode` attributes. > - Implemented protected virtual methods to read / write `OpcVariableNode` value attributes. > - The `OpcSession` class now provides the properties `UsedIdentity` and `SuppliedIdentity`. > - Implemented the `Update` method on `OpcStatus`. > - The `OpcContext` now provides an `Identity` property. > - Implemented the new `OpcMonitoredItem` class in the server namespace. > - `OnMonitoredItemCreated/Deleted/Modified` now provides non-Foundation classes. > > **Changed** > - Moved the `Identity` and `ImpersonationContext` classes from the `Opc.UaFx.Server` to the `Opc.UaFx` namespace. > **1.5.2.0 (released on June 18, 2015)** > > **New** > - Excluded the auto update of the endpoint before the connect in cases where a preferred endpoint is defined in `OpcClient`. > - Implemented new endpoint identity security on `OpcSecurity` to enable / disable different endpoints for one or more ACEs. Additionally renamed some existing methods. > - Implemented the `StateChanged` event in `OpcClient`. > **1.5.1.1 (released on June 16, 2015)** > > **New** > - Implemented the `InvokeService` method in `OpcClient` to invoke service routines using a try-catch-finally block to ensure that the client's state property also handles its connection state in case of an exception which indicates that the connection has timed out or been lost. > > **Fixed** > - Issue with null references as DisplayName and BrowseName in `OpcReferenceDescription`. > **1.5.1.0 (released on June 15, 2015)** > > **New** > - Implemented the `SaveCertificate` method on `OpcCertificateManager`. > - Reworked the complete argument binding to also support `out` and `ref` parameters in `OpcMethodNode`. > - Implemented `ByRef` type support in `OpcMethodNode`. > - Implemented the local server `CertificateValidationFailed` event to support custom actions on failed certificate validation. > - Implemented the new `OpcMethodNodeInfo` class derived from `OpcNodeInfo` to browse the arguments of method nodes. > - Implemented the new `OpcCertificateValidationFailedEventArgs` and `OpcCertificateValidationFailedEventHandler`. > - Implemented the `DataType` property on `OpcDataVariableNode`. > - Implemented the `InputArguments` and `OutputArguments` properties on the `OpcMethodNode` class. Additionally extended the support of `OpcArgument` instances with the `OpcArgumentAttribute` on custom delegates. > - Implemented support for null references in all implicit cast operators which are working with reference types. > **1.5.0.0 (released on June 10, 2015)** > > - **New:** Implemented logic to generate a server-fulfilled configuration on start. > - **New:** Completely reworked the endpoint selection using the `OpcDiscoveryClient` and the custom preferred `OpcSecurityPolicy`. > - **New:** Improved the auto complete of the configuration depending on its application type. > - **New:** Introduced transport profile information. > - **New:** Moved the configuration of `UserTokenPolicies` to `OpcServer` on startup and improved the transparency of the `IsEnabled` property. > - **Fixed:** Issue with empty certificate store paths. > - **New:** Completely reworked the node referencing mechanism to provide more information while building the node references and to also remove OPC internals from the user API. > - **New:** Completely reworked existing node implementations and moved their base class reference to an internal reference to improve the experience with the SDK and become more `CLSCompliant` by also providing more useful APIs. > - **New:** Implemented support for discovery server base address configuration. > - **New:** Improved configuration defaults, also when loading configuration through one of the `Load` methods. Additionally implemented default support for `DiscoveryServerConfigurations`. > - **New:** Simplified the API further. > - **New:** Introduced `OpcStatus` as replacement for `StatusCode`. > - **New:** Reworked `OpcDiscoveryClient` from factory methods to constructor use to provide a fluent interface between all server and client classes. ### 1.4 > **1.4.0.0 (released on June 9, 2015)** > > **New** > - Merged `Opc.ClientFx.Advanced` and `Opc.ServerFx.Advanced` together into `Opc.UaFx.Advanced`. ### 1.0 > **1.0.0.0 (released on January 11, 2015)** > > **New** > - Created `Opc.ClientFx.Advanced` and `Opc.ServerFx.Advanced`.