diff --git a/Libraries/Opc.Ua.Client/DefaultSessionFactory.cs b/Libraries/Opc.Ua.Client/DefaultSessionFactory.cs index 4adbeebc1..58b1b03d1 100644 --- a/Libraries/Opc.Ua.Client/DefaultSessionFactory.cs +++ b/Libraries/Opc.Ua.Client/DefaultSessionFactory.cs @@ -29,6 +29,7 @@ using System; using System.Collections.Generic; +using System.Security.Cryptography.X509Certificates; using System.Threading; using System.Threading.Tasks; @@ -39,9 +40,21 @@ namespace Opc.Ua.Client /// public class DefaultSessionFactory : ISessionFactory { + /// + /// The default instance of the factory. + /// + public static readonly DefaultSessionFactory Instance = new DefaultSessionFactory(); + + /// + /// Force use of the default instance. + /// + protected DefaultSessionFactory() + { + } + #region Public Methods /// - public async Task CreateAsync( + public async virtual Task CreateAsync( ApplicationConfiguration configuration, ConfiguredEndpoint endpoint, bool updateBeforeConnect, @@ -55,7 +68,7 @@ public async Task CreateAsync( } /// - public async Task CreateAsync( + public async virtual Task CreateAsync( ApplicationConfiguration configuration, ConfiguredEndpoint endpoint, bool updateBeforeConnect, @@ -71,7 +84,7 @@ public async Task CreateAsync( } /// - public async Task CreateAsync( + public async virtual Task CreateAsync( ApplicationConfiguration configuration, ITransportWaitingConnection connection, ConfiguredEndpoint endpoint, @@ -89,7 +102,7 @@ public async Task CreateAsync( } /// - public async Task CreateAsync( + public async virtual Task CreateAsync( ApplicationConfiguration configuration, ReverseConnectManager reverseConnectManager, ConfiguredEndpoint endpoint, @@ -102,7 +115,6 @@ public async Task CreateAsync( CancellationToken ct = default ) { - if (reverseConnectManager == null) { return await CreateAsync(configuration, endpoint, updateBeforeConnect, @@ -141,7 +153,25 @@ await endpoint.UpdateFromServerAsync( } /// - public Task RecreateAsync(ISession sessionTemplate) + public virtual ISession Create( + ApplicationConfiguration configuration, + ITransportChannel channel, + ConfiguredEndpoint endpoint, + X509Certificate2 clientCertificate, + EndpointDescriptionCollection availableEndpoints = null, + StringCollection discoveryProfileUris = null) + { + return Session.Create(configuration, channel, endpoint, clientCertificate, availableEndpoints, discoveryProfileUris); + } + + /// + public virtual Task CreateChannelAsync(ApplicationConfiguration configuration, ITransportWaitingConnection connection, ConfiguredEndpoint endpoint, bool updateBeforeConnect, bool checkDomain) + { + return Session.CreateChannelAsync(configuration, connection, endpoint, updateBeforeConnect, checkDomain); + } + + /// + public virtual Task RecreateAsync(ISession sessionTemplate) { if (!(sessionTemplate is Session template)) { @@ -152,7 +182,7 @@ public Task RecreateAsync(ISession sessionTemplate) } /// - public Task RecreateAsync(ISession sessionTemplate, ITransportWaitingConnection connection) + public virtual Task RecreateAsync(ISession sessionTemplate, ITransportWaitingConnection connection) { if (!(sessionTemplate is Session template)) { diff --git a/Libraries/Opc.Ua.Client/ISessionFactory.cs b/Libraries/Opc.Ua.Client/ISessionFactory.cs index cb706d669..c01917204 100644 --- a/Libraries/Opc.Ua.Client/ISessionFactory.cs +++ b/Libraries/Opc.Ua.Client/ISessionFactory.cs @@ -28,6 +28,7 @@ * ======================================================================*/ using System.Collections.Generic; +using System.Security.Cryptography.X509Certificates; using System.Threading; using System.Threading.Tasks; @@ -131,6 +132,39 @@ Task CreateAsync( IList preferredLocales, CancellationToken ct = default); + /// + /// Creates a secure channel to the specified endpoint. + /// + /// The application configuration. + /// The client endpoint for the reverse connect. + /// A configured endpoint to connect to. + /// Update configuration based on server prior connect. + /// Check that the certificate specifies a valid domain (computer) name. + /// A representing the asynchronous operation. + Task CreateChannelAsync( + ApplicationConfiguration configuration, + ITransportWaitingConnection connection, + ConfiguredEndpoint endpoint, + bool updateBeforeConnect, + bool checkDomain); + + /// + /// Creates a new session with a server using the specified channel by invoking the CreateSession service. + /// + /// The configuration for the client application. + /// The channel for the server. + /// The endpoint for the server. + /// The certificate to use for the client. + /// The list of available endpoints returned by server in GetEndpoints() response. + /// The value of profileUris used in GetEndpoints() request. + ISession Create( + ApplicationConfiguration configuration, + ITransportChannel channel, + ConfiguredEndpoint endpoint, + X509Certificate2 clientCertificate, + EndpointDescriptionCollection availableEndpoints = null, + StringCollection discoveryProfileUris = null); + /// /// Recreates a session based on a specified template. /// diff --git a/Libraries/Opc.Ua.Client/Session.cs b/Libraries/Opc.Ua.Client/Session.cs index ee88800c4..1fd58585b 100644 --- a/Libraries/Opc.Ua.Client/Session.cs +++ b/Libraries/Opc.Ua.Client/Session.cs @@ -251,7 +251,7 @@ private void Initialize( /// private void Initialize() { - m_sessionFactory = new DefaultSessionFactory(); + m_sessionFactory = DefaultSessionFactory.Instance; m_sessionTimeout = 0; m_namespaceUris = new NamespaceTable(); m_serverUris = new StringTable(); diff --git a/Libraries/Opc.Ua.Client/TraceableSession.cs b/Libraries/Opc.Ua.Client/TraceableSession.cs new file mode 100644 index 000000000..6deb34716 --- /dev/null +++ b/Libraries/Opc.Ua.Client/TraceableSession.cs @@ -0,0 +1,1913 @@ +/* ======================================================================== + * Copyright (c) 2005-2023 The OPC Foundation, Inc. All rights reserved. + * + * OPC Foundation MIT License 1.00 + * + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software and associated documentation + * files (the "Software"), to deal in the Software without + * restriction, including without limitation the rights to use, + * copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following + * conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES + * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT + * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + * + * The complete license agreement can be found here: + * http://opcfoundation.org/License/MIT/1.00/ + * ======================================================================*/ + +#if NET6_0_OR_GREATER +using System; +using System.Collections.Generic; +using System.Diagnostics; +using System.IO; +using System.Threading; +using System.Threading.Tasks; + +namespace Opc.Ua.Client +{ + /// + /// Decorator class for traceable session with Activity Source. + /// + public class TraceableSession : ISession + { + #region Constructors + /// + /// Initializes a new instance of the class. + /// + public TraceableSession(ISession session) + { + m_session = session; + } + #endregion + + /// + /// Activity Source Name. + /// + public static readonly string ActivitySourceName = "Opc.Ua.Client-TraceableSession-ActivitySource"; + + /// + /// Activity Source static instance. + /// + public static ActivitySource ActivitySource => s_activitySource.Value; + private static readonly Lazy s_activitySource = new Lazy(() => new ActivitySource(ActivitySourceName)); + + /// + /// The ISession which is being traced. + /// + private ISession m_session; + + /// + public ISession Session => m_session; + + #region ISession interface + /// + public event KeepAliveEventHandler KeepAlive + { + add => m_session.KeepAlive += value; + remove => m_session.KeepAlive -= value; + } + + /// + public event NotificationEventHandler Notification + { + add => m_session.Notification += value; + remove => m_session.Notification -= value; + } + + /// + public event PublishErrorEventHandler PublishError + { + add => m_session.PublishError += value; + remove => m_session.PublishError -= value; + } + + /// + public event PublishSequenceNumbersToAcknowledgeEventHandler PublishSequenceNumbersToAcknowledge + { + add => m_session.PublishSequenceNumbersToAcknowledge += value; + remove => m_session.PublishSequenceNumbersToAcknowledge -= value; + } + + /// + public event EventHandler SubscriptionsChanged + { + add => m_session.SubscriptionsChanged += value; + remove => m_session.SubscriptionsChanged -= value; + } + + /// + public event EventHandler SessionClosing + { + add => m_session.SessionClosing += value; + remove => m_session.SessionClosing -= value; + } + + /// + public event RenewUserIdentityEventHandler RenewUserIdentity + { + add => m_session.RenewUserIdentity += value; + remove => m_session.RenewUserIdentity -= value; + } + + /// + public ISessionFactory SessionFactory => TraceableSessionFactory.Instance; + + /// + public ConfiguredEndpoint ConfiguredEndpoint => m_session.ConfiguredEndpoint; + + /// + public string SessionName => m_session.SessionName; + + /// + public double SessionTimeout => m_session.SessionTimeout; + + /// + public object Handle => m_session.Handle; + + /// + public IUserIdentity Identity => m_session.Identity; + + /// + public IEnumerable IdentityHistory => m_session.IdentityHistory; + + /// + public NamespaceTable NamespaceUris => m_session.NamespaceUris; + + /// + public StringTable ServerUris => m_session.ServerUris; + + /// + public ISystemContext SystemContext => m_session.SystemContext; + + /// + public IEncodeableFactory Factory => m_session.Factory; + + /// + public ITypeTable TypeTree => m_session.TypeTree; + + /// + public INodeCache NodeCache => m_session.NodeCache; + + /// + public FilterContext FilterContext => m_session.FilterContext; + + /// + public StringCollection PreferredLocales => m_session.PreferredLocales; + + /// + public IReadOnlyDictionary DataTypeSystem => m_session.DataTypeSystem; + + /// + public IEnumerable Subscriptions => m_session.Subscriptions; + + /// + public int SubscriptionCount => m_session.SubscriptionCount; + + /// + public bool DeleteSubscriptionsOnClose + { + get => m_session.DeleteSubscriptionsOnClose; + set => m_session.DeleteSubscriptionsOnClose = value; + } + + /// + public Subscription DefaultSubscription + { + get => m_session.DefaultSubscription; + set => m_session.DefaultSubscription = value; + } + + /// + public int KeepAliveInterval + { + get => m_session.KeepAliveInterval; + set => m_session.KeepAliveInterval = value; + } + + /// + public bool KeepAliveStopped => m_session.KeepAliveStopped; + + /// + public DateTime LastKeepAliveTime => m_session.LastKeepAliveTime; + + /// + public int OutstandingRequestCount => m_session.OutstandingRequestCount; + + /// + public int DefunctRequestCount => m_session.DefunctRequestCount; + + /// + public int GoodPublishRequestCount => m_session.GoodPublishRequestCount; + + /// + public int MinPublishRequestCount + { + get => m_session.MinPublishRequestCount; + set => m_session.MinPublishRequestCount = value; + } + + /// + public OperationLimits OperationLimits => m_session.OperationLimits; + + /// + public bool TransferSubscriptionsOnReconnect + { + get => m_session.TransferSubscriptionsOnReconnect; + set => m_session.TransferSubscriptionsOnReconnect = value; + } + + /// + public NodeId SessionId => m_session.SessionId; + + /// + public bool Connected => m_session.Connected; + + /// + public EndpointDescription Endpoint => m_session.Endpoint; + + /// + public EndpointConfiguration EndpointConfiguration => m_session.EndpointConfiguration; + + /// + public IServiceMessageContext MessageContext => m_session.MessageContext; + + /// + public ITransportChannel TransportChannel => m_session.TransportChannel; + + /// + public DiagnosticsMasks ReturnDiagnostics + { + get => m_session.ReturnDiagnostics; + set => m_session.ReturnDiagnostics = value; + } + + /// + public int OperationTimeout + { + get => m_session.OperationTimeout; + set => m_session.OperationTimeout = value; + } + + /// + public bool Disposed => m_session.Disposed; + + /// + public bool CheckDomain => m_session.CheckDomain; + + /// + public void Reconnect() + { + using (Activity activity = ActivitySource.StartActivity(nameof(Reconnect))) + { + m_session.Reconnect(); + } + } + + /// + public void Reconnect(ITransportWaitingConnection connection) + { + using (Activity activity = ActivitySource.StartActivity(nameof(Reconnect))) + { + m_session.Reconnect(connection); + } + } + + /// + public void Reconnect(ITransportChannel channel) + { + using (Activity activity = ActivitySource.StartActivity(nameof(Reconnect))) + { + m_session.Reconnect(channel); + } + } + + /// + public void Save(string filePath) + { + using (Activity activity = ActivitySource.StartActivity(nameof(Save))) + { + m_session.Save(filePath); + } + } + + /// + public void Save(Stream stream, IEnumerable subscriptions) + { + using (Activity activity = ActivitySource.StartActivity(nameof(Save))) + { + m_session.Save(stream, subscriptions); + } + } + + /// + public void Save(string filePath, IEnumerable subscriptions) + { + using (Activity activity = ActivitySource.StartActivity(nameof(Save))) + { + m_session.Save(filePath, subscriptions); + } + } + + /// + public IEnumerable Load(Stream stream, bool transferSubscriptions = false) + { + using (Activity activity = ActivitySource.StartActivity(nameof(Load))) + { + return m_session.Load(stream, transferSubscriptions); + } + } + + /// + public IEnumerable Load(string filePath, bool transferSubscriptions = false) + { + using (Activity activity = ActivitySource.StartActivity(nameof(Load))) + { + return m_session.Load(filePath, transferSubscriptions); + } + } + + /// + public void FetchNamespaceTables() + { + using (Activity activity = ActivitySource.StartActivity(nameof(FetchNamespaceTables))) + { + m_session.FetchNamespaceTables(); + } + } + + /// + public void FetchTypeTree(ExpandedNodeId typeId) + { + using (Activity activity = ActivitySource.StartActivity(nameof(FetchTypeTree))) + { + m_session.FetchTypeTree(typeId); + } + } + + /// + public void FetchTypeTree(ExpandedNodeIdCollection typeIds) + { + using (Activity activity = ActivitySource.StartActivity(nameof(FetchTypeTree))) + { + m_session.FetchTypeTree(typeIds); + } + } + + /// + public ReferenceDescriptionCollection ReadAvailableEncodings(NodeId variableId) + { + using (Activity activity = ActivitySource.StartActivity(nameof(ReadAvailableEncodings))) + { + return m_session.ReadAvailableEncodings(variableId); + } + } + + /// + public ReferenceDescription FindDataDescription(NodeId encodingId) + { + using (Activity activity = ActivitySource.StartActivity(nameof(FindDataDescription))) + { + return m_session.FindDataDescription(encodingId); + } + } + + /// + public Task FindDataDictionary(NodeId descriptionId) + { + using (Activity activity = ActivitySource.StartActivity(nameof(FindDataDictionary))) + { + return m_session.FindDataDictionary(descriptionId); + } + } + + /// + public async Task LoadDataDictionary(ReferenceDescription dictionaryNode, bool forceReload = false) + { + using (Activity activity = ActivitySource.StartActivity(nameof(LoadDataDictionary))) + { + return await m_session.LoadDataDictionary(dictionaryNode, forceReload).ConfigureAwait(false); + } + } + + /// + public async Task> LoadDataTypeSystem(NodeId dataTypeSystem = null) + { + using (Activity activity = ActivitySource.StartActivity(nameof(LoadDataTypeSystem))) + { + return await m_session.LoadDataTypeSystem(dataTypeSystem).ConfigureAwait(false); + } + } + + /// + public Node ReadNode(NodeId nodeId) + { + using (Activity activity = ActivitySource.StartActivity(nameof(ReadNode))) + { + return m_session.ReadNode(nodeId); + } + } + + /// + public Node ReadNode(NodeId nodeId, NodeClass nodeClass, bool optionalAttributes = true) + { + using (Activity activity = ActivitySource.StartActivity(nameof(ReadNode))) + { + return m_session.ReadNode(nodeId, nodeClass, optionalAttributes); + } + } + + /// + public void ReadNodes(IList nodeIds, out IList nodeCollection, out IList errors, bool optionalAttributes = false) + { + using (Activity activity = ActivitySource.StartActivity(nameof(ReadNodes))) + { + m_session.ReadNodes(nodeIds, out nodeCollection, out errors, optionalAttributes); + } + } + + /// + public void ReadNodes(IList nodeIds, NodeClass nodeClass, out IList nodeCollection, out IList errors, bool optionalAttributes = false) + { + using (Activity activity = ActivitySource.StartActivity(nameof(ReadNodes))) + { + m_session.ReadNodes(nodeIds, nodeClass, out nodeCollection, out errors, optionalAttributes); + } + } + + /// + public DataValue ReadValue(NodeId nodeId) + { + using (Activity activity = ActivitySource.StartActivity(nameof(ReadValue))) + { + return m_session.ReadValue(nodeId); + } + } + + /// + public object ReadValue(NodeId nodeId, Type expectedType) + { + using (Activity activity = ActivitySource.StartActivity(nameof(ReadValue))) + { + return m_session.ReadValue(nodeId, expectedType); + } + } + + /// + public void ReadValues(IList nodeIds, out DataValueCollection values, out IList errors) + { + using (Activity activity = ActivitySource.StartActivity(nameof(ReadValues))) + { + m_session.ReadValues(nodeIds, out values, out errors); + } + } + + /// + public ReferenceDescriptionCollection FetchReferences(NodeId nodeId) + { + using (Activity activity = ActivitySource.StartActivity(nameof(FetchReferences))) + { + return m_session.FetchReferences(nodeId); + } + } + + /// + public void FetchReferences(IList nodeIds, out IList referenceDescriptions, out IList errors) + { + using (Activity activity = ActivitySource.StartActivity(nameof(FetchReferences))) + { + m_session.FetchReferences(nodeIds, out referenceDescriptions, out errors); + } + } + + /// + public void Open(string sessionName, IUserIdentity identity) + { + using (Activity activity = ActivitySource.StartActivity(nameof(Open))) + { + m_session.Open(sessionName, identity); + } + } + + /// + public void Open(string sessionName, uint sessionTimeout, IUserIdentity identity, IList preferredLocales) + { + using (Activity activity = ActivitySource.StartActivity(nameof(Open))) + { + m_session.Open(sessionName, sessionTimeout, identity, preferredLocales); + } + } + + /// + public void Open(string sessionName, uint sessionTimeout, IUserIdentity identity, IList preferredLocales, bool checkDomain) + { + using (Activity activity = ActivitySource.StartActivity(nameof(Open))) + { + m_session.Open(sessionName, sessionTimeout, identity, preferredLocales, checkDomain); + } + } + + /// + public void ChangePreferredLocales(StringCollection preferredLocales) + { + using (Activity activity = ActivitySource.StartActivity(nameof(ChangePreferredLocales))) + { + m_session.ChangePreferredLocales(preferredLocales); + } + } + + /// + public void UpdateSession(IUserIdentity identity, StringCollection preferredLocales) + { + using (Activity activity = ActivitySource.StartActivity(nameof(UpdateSession))) + { + m_session.UpdateSession(identity, preferredLocales); + } + } + + /// + public void FindComponentIds(NodeId instanceId, IList componentPaths, out NodeIdCollection componentIds, out List errors) + { + using (Activity activity = ActivitySource.StartActivity(nameof(FindComponentIds))) + { + m_session.FindComponentIds(instanceId, componentPaths, out componentIds, out errors); + } + } + + /// + public void ReadValues(IList variableIds, IList expectedTypes, out List values, out List errors) + { + using (Activity activity = ActivitySource.StartActivity(nameof(ReadValues))) + { + m_session.ReadValues(variableIds, expectedTypes, out values, out errors); + } + } + + /// + public void ReadDisplayName(IList nodeIds, out IList displayNames, out IList errors) + { + using (Activity activity = ActivitySource.StartActivity(nameof(ReadDisplayName))) + { + m_session.ReadDisplayName(nodeIds, out displayNames, out errors); + } + } + /// + public async Task<(IList, IList)> ReadNodesAsync(IList nodeIds, NodeClass nodeClass, bool optionalAttributes = false, CancellationToken ct = default) + { + using (Activity activity = ActivitySource.StartActivity(nameof(ReadNodesAsync))) + { + return await m_session.ReadNodesAsync(nodeIds, nodeClass, optionalAttributes, ct).ConfigureAwait(false); + } + } + + /// + public async Task ReadValueAsync(NodeId nodeId, CancellationToken ct = default) + { + using (Activity activity = ActivitySource.StartActivity(nameof(ReadValueAsync))) + { + return await m_session.ReadValueAsync(nodeId, ct).ConfigureAwait(false); + } + } + + /// + public async Task ReadNodeAsync(NodeId nodeId, CancellationToken ct = default) + { + using (Activity activity = ActivitySource.StartActivity(nameof(ReadNodeAsync))) + { + return await m_session.ReadNodeAsync(nodeId, ct).ConfigureAwait(false); + } + } + + /// + public async Task ReadNodeAsync(NodeId nodeId, NodeClass nodeClass, bool optionalAttributes = true, CancellationToken ct = default) + { + using (Activity activity = ActivitySource.StartActivity(nameof(ReadNodeAsync))) + { + return await m_session.ReadNodeAsync(nodeId, nodeClass, optionalAttributes, ct).ConfigureAwait(false); + } + } + + /// + public async Task<(IList, IList)> ReadNodesAsync(IList nodeIds, bool optionalAttributes = false, CancellationToken ct = default) + { + using (Activity activity = ActivitySource.StartActivity(nameof(ReadNodesAsync))) + { + return await m_session.ReadNodesAsync(nodeIds, optionalAttributes, ct).ConfigureAwait(false); + } + } + + /// + public async Task<(DataValueCollection, IList)> ReadValuesAsync(IList nodeIds, CancellationToken ct = default) + { + using (Activity activity = ActivitySource.StartActivity(nameof(ReadValuesAsync))) + { + return await m_session.ReadValuesAsync(nodeIds, ct).ConfigureAwait(false); + } + } + + /// + public StatusCode Close(int timeout) + { + using (Activity activity = ActivitySource.StartActivity(nameof(Close))) + { + return m_session.Close(timeout); + } + } + + /// + public StatusCode Close(bool closeChannel) + { + using (Activity activity = ActivitySource.StartActivity(nameof(Close))) + { + return m_session.Close(closeChannel); + } + } + + /// + public StatusCode Close(int timeout, bool closeChannel) + { + using (Activity activity = ActivitySource.StartActivity(nameof(Close))) + { + return m_session.Close(timeout, closeChannel); + } + } + + /// + public async Task CloseAsync(CancellationToken ct = default) + { + using (Activity activity = ActivitySource.StartActivity(nameof(CloseAsync))) + { + return await m_session.CloseAsync(ct).ConfigureAwait(false); + } + } + + /// + public async Task CloseAsync(bool closeChannel, CancellationToken ct = default) + { + using (Activity activity = ActivitySource.StartActivity(nameof(CloseAsync))) + { + return await m_session.CloseAsync(closeChannel, ct).ConfigureAwait(false); + } + } + + /// + public async Task CloseAsync(int timeout, CancellationToken ct = default) + { + using (Activity activity = ActivitySource.StartActivity(nameof(CloseAsync))) + { + return await m_session.CloseAsync(timeout, ct).ConfigureAwait(false); + } + } + + /// + public async Task CloseAsync(int timeout, bool closeChannel, CancellationToken ct = default) + { + using (Activity activity = ActivitySource.StartActivity(nameof(CloseAsync))) + { + return await m_session.CloseAsync(timeout, closeChannel, ct).ConfigureAwait(false); + } + } + + /// + public bool AddSubscription(Subscription subscription) + { + using (Activity activity = ActivitySource.StartActivity(nameof(AddSubscription))) + { + return m_session.AddSubscription(subscription); + } + } + + /// + public bool RemoveSubscription(Subscription subscription) + { + using (Activity activity = ActivitySource.StartActivity(nameof(RemoveSubscription))) + { + return m_session.RemoveSubscription(subscription); + } + } + + /// + public bool RemoveSubscriptions(IEnumerable subscriptions) + { + using (Activity activity = ActivitySource.StartActivity(nameof(RemoveSubscriptions))) + { + return m_session.RemoveSubscriptions(subscriptions); + } + } + + /// + public bool TransferSubscriptions(SubscriptionCollection subscriptions, bool sendInitialValues) + { + using (Activity activity = ActivitySource.StartActivity(nameof(TransferSubscriptions))) + { + return m_session.TransferSubscriptions(subscriptions, sendInitialValues); + } + } + + /// + public bool RemoveTransferredSubscription(Subscription subscription) + { + using (Activity activity = ActivitySource.StartActivity(nameof(RemoveTransferredSubscription))) + { + return m_session.RemoveTransferredSubscription(subscription); + } + } + + /// + public async Task RemoveSubscriptionAsync(Subscription subscription) + { + using (Activity activity = ActivitySource.StartActivity(nameof(RemoveSubscriptionAsync))) + { + return await m_session.RemoveSubscriptionAsync(subscription).ConfigureAwait(false); + } + } + + /// + public async Task RemoveSubscriptionsAsync(IEnumerable subscriptions) + { + using (Activity activity = ActivitySource.StartActivity(nameof(RemoveSubscriptionsAsync))) + { + return await m_session.RemoveSubscriptionsAsync(subscriptions).ConfigureAwait(false); + } + } + + /// + public ResponseHeader Browse(RequestHeader requestHeader, ViewDescription view, NodeId nodeToBrowse, uint maxResultsToReturn, BrowseDirection browseDirection, NodeId referenceTypeId, bool includeSubtypes, uint nodeClassMask, out byte[] continuationPoint, out ReferenceDescriptionCollection references) + { + using (Activity activity = ActivitySource.StartActivity(nameof(Browse))) + { + return m_session.Browse(requestHeader, view, nodeToBrowse, maxResultsToReturn, browseDirection, referenceTypeId, includeSubtypes, nodeClassMask, out continuationPoint, out references); + } + } + + /// + public IAsyncResult BeginBrowse(RequestHeader requestHeader, ViewDescription view, NodeId nodeToBrowse, uint maxResultsToReturn, BrowseDirection browseDirection, NodeId referenceTypeId, bool includeSubtypes, uint nodeClassMask, AsyncCallback callback, object asyncState) + { + return m_session.BeginBrowse(requestHeader, view, nodeToBrowse, maxResultsToReturn, browseDirection, referenceTypeId, includeSubtypes, nodeClassMask, callback, asyncState); + } + + /// + public ResponseHeader EndBrowse(IAsyncResult result, out byte[] continuationPoint, out ReferenceDescriptionCollection references) + { + return m_session.EndBrowse(result, out continuationPoint, out references); + } + + /// + public ResponseHeader BrowseNext(RequestHeader requestHeader, bool releaseContinuationPoint, byte[] continuationPoint, out byte[] revisedContinuationPoint, out ReferenceDescriptionCollection references) + { + using (Activity activity = ActivitySource.StartActivity(nameof(BrowseNext))) + { + return m_session.BrowseNext(requestHeader, releaseContinuationPoint, continuationPoint, out revisedContinuationPoint, out references); + } + } + + /// + public IAsyncResult BeginBrowseNext(RequestHeader requestHeader, bool releaseContinuationPoint, byte[] continuationPoint, AsyncCallback callback, object asyncState) + { + return m_session.BeginBrowseNext(requestHeader, releaseContinuationPoint, continuationPoint, callback, asyncState); + } + + /// + public ResponseHeader EndBrowseNext(IAsyncResult result, out byte[] revisedContinuationPoint, out ReferenceDescriptionCollection references) + { + return m_session.EndBrowseNext(result, out revisedContinuationPoint, out references); + } + + /// + public IList Call(NodeId objectId, NodeId methodId, params object[] args) + { + using (Activity activity = ActivitySource.StartActivity(nameof(Call))) + { + return m_session.Call(objectId, methodId, args); + } + } + + /// + public IAsyncResult BeginPublish(int timeout) + { + return m_session.BeginPublish(timeout); + } + + /// + public bool Republish(uint subscriptionId, uint sequenceNumber) + { + using (Activity activity = ActivitySource.StartActivity(nameof(Republish))) + { + return m_session.Republish(subscriptionId, sequenceNumber); + } + } + + /// + public ResponseHeader CreateSession(RequestHeader requestHeader, ApplicationDescription clientDescription, string serverUri, string endpointUrl, string sessionName, byte[] clientNonce, byte[] clientCertificate, double requestedSessionTimeout, uint maxResponseMessageSize, out NodeId sessionId, out NodeId authenticationToken, out double revisedSessionTimeout, out byte[] serverNonce, out byte[] serverCertificate, out EndpointDescriptionCollection serverEndpoints, out SignedSoftwareCertificateCollection serverSoftwareCertificates, out SignatureData serverSignature, out uint maxRequestMessageSize) + { + using (Activity activity = ActivitySource.StartActivity(nameof(CreateSession))) + { + return m_session.CreateSession(requestHeader, clientDescription, serverUri, endpointUrl, sessionName, clientNonce, clientCertificate, requestedSessionTimeout, maxResponseMessageSize, out sessionId, out authenticationToken, out revisedSessionTimeout, out serverNonce, out serverCertificate, out serverEndpoints, out serverSoftwareCertificates, out serverSignature, out maxRequestMessageSize); + } + } + + /// + public IAsyncResult BeginCreateSession(RequestHeader requestHeader, ApplicationDescription clientDescription, string serverUri, string endpointUrl, string sessionName, byte[] clientNonce, byte[] clientCertificate, double requestedSessionTimeout, uint maxResponseMessageSize, AsyncCallback callback, object asyncState) + { + return m_session.BeginCreateSession(requestHeader, clientDescription, serverUri, endpointUrl, sessionName, clientNonce, clientCertificate, requestedSessionTimeout, maxResponseMessageSize, callback, asyncState); + } + + /// + public ResponseHeader EndCreateSession(IAsyncResult result, out NodeId sessionId, out NodeId authenticationToken, out double revisedSessionTimeout, out byte[] serverNonce, out byte[] serverCertificate, out EndpointDescriptionCollection serverEndpoints, out SignedSoftwareCertificateCollection serverSoftwareCertificates, out SignatureData serverSignature, out uint maxRequestMessageSize) + { + return m_session.EndCreateSession(result, out sessionId, out authenticationToken, out revisedSessionTimeout, out serverNonce, out serverCertificate, out serverEndpoints, out serverSoftwareCertificates, out serverSignature, out maxRequestMessageSize); + } + + /// + public async Task CreateSessionAsync(RequestHeader requestHeader, ApplicationDescription clientDescription, string serverUri, string endpointUrl, string sessionName, byte[] clientNonce, byte[] clientCertificate, double requestedSessionTimeout, uint maxResponseMessageSize, CancellationToken ct) + { + using (Activity activity = ActivitySource.StartActivity(nameof(CreateSessionAsync))) + { + return await m_session.CreateSessionAsync(requestHeader, clientDescription, serverUri, endpointUrl, sessionName, clientNonce, clientCertificate, requestedSessionTimeout, maxResponseMessageSize, ct).ConfigureAwait(false); + } + } + + /// + public ResponseHeader ActivateSession(RequestHeader requestHeader, SignatureData clientSignature, SignedSoftwareCertificateCollection clientSoftwareCertificates, StringCollection localeIds, ExtensionObject userIdentityToken, SignatureData userTokenSignature, out byte[] serverNonce, out StatusCodeCollection results, out DiagnosticInfoCollection diagnosticInfos) + { + using (Activity activity = ActivitySource.StartActivity(nameof(ActivateSession))) + { + return m_session.ActivateSession(requestHeader, clientSignature, clientSoftwareCertificates, localeIds, userIdentityToken, userTokenSignature, out serverNonce, out results, out diagnosticInfos); + } + } + + /// + public IAsyncResult BeginActivateSession(RequestHeader requestHeader, SignatureData clientSignature, SignedSoftwareCertificateCollection clientSoftwareCertificates, StringCollection localeIds, ExtensionObject userIdentityToken, SignatureData userTokenSignature, AsyncCallback callback, object asyncState) + { + return m_session.BeginActivateSession(requestHeader, clientSignature, clientSoftwareCertificates, localeIds, userIdentityToken, userTokenSignature, callback, asyncState); + } + + /// + public ResponseHeader EndActivateSession(IAsyncResult result, out byte[] serverNonce, out StatusCodeCollection results, out DiagnosticInfoCollection diagnosticInfos) + { + return m_session.EndActivateSession(result, out serverNonce, out results, out diagnosticInfos); + } + + /// + public async Task ActivateSessionAsync(RequestHeader requestHeader, SignatureData clientSignature, SignedSoftwareCertificateCollection clientSoftwareCertificates, StringCollection localeIds, ExtensionObject userIdentityToken, SignatureData userTokenSignature, CancellationToken ct) + { + using (Activity activity = ActivitySource.StartActivity(nameof(ActivateSessionAsync))) + { + return await m_session.ActivateSessionAsync(requestHeader, clientSignature, clientSoftwareCertificates, localeIds, userIdentityToken, userTokenSignature, ct).ConfigureAwait(false); + } + } + + /// + public ResponseHeader CloseSession(RequestHeader requestHeader, bool deleteSubscriptions) + { + using (Activity activity = ActivitySource.StartActivity(nameof(CloseSession))) + { + return m_session.CloseSession(requestHeader, deleteSubscriptions); + } + } + + /// + public IAsyncResult BeginCloseSession(RequestHeader requestHeader, bool deleteSubscriptions, AsyncCallback callback, object asyncState) + { + return m_session.BeginCloseSession(requestHeader, deleteSubscriptions, callback, asyncState); + } + + /// + public ResponseHeader EndCloseSession(IAsyncResult result) + { + return m_session.EndCloseSession(result); + } + + /// + public async Task CloseSessionAsync(RequestHeader requestHeader, bool deleteSubscriptions, CancellationToken ct) + { + using (Activity activity = ActivitySource.StartActivity(nameof(CloseSessionAsync))) + { + return await m_session.CloseSessionAsync(requestHeader, deleteSubscriptions, ct).ConfigureAwait(false); + } + } + + /// + public ResponseHeader Cancel(RequestHeader requestHeader, uint requestHandle, out uint cancelCount) + { + using (Activity activity = ActivitySource.StartActivity(nameof(Cancel))) + { + return m_session.Cancel(requestHeader, requestHandle, out cancelCount); + } + } + + /// + public IAsyncResult BeginCancel(RequestHeader requestHeader, uint requestHandle, AsyncCallback callback, object asyncState) + { + return m_session.BeginCancel(requestHeader, requestHandle, callback, asyncState); + } + + /// + public ResponseHeader EndCancel(IAsyncResult result, out uint cancelCount) + { + return m_session.EndCancel(result, out cancelCount); + } + + /// + public Task CancelAsync(RequestHeader requestHeader, uint requestHandle, CancellationToken ct) + { + using (Activity activity = ActivitySource.StartActivity(nameof(CancelAsync))) + { + return m_session.CancelAsync(requestHeader, requestHandle, ct); + } + } + + /// + public ResponseHeader AddNodes(RequestHeader requestHeader, AddNodesItemCollection nodesToAdd, out AddNodesResultCollection results, out DiagnosticInfoCollection diagnosticInfos) + { + using (Activity activity = ActivitySource.StartActivity(nameof(AddNodes))) + { + return m_session.AddNodes(requestHeader, nodesToAdd, out results, out diagnosticInfos); + } + } + + /// + public IAsyncResult BeginAddNodes(RequestHeader requestHeader, AddNodesItemCollection nodesToAdd, AsyncCallback callback, object asyncState) + { + return m_session.BeginAddNodes(requestHeader, nodesToAdd, callback, asyncState); + } + + /// + public ResponseHeader EndAddNodes(IAsyncResult result, out AddNodesResultCollection results, out DiagnosticInfoCollection diagnosticInfos) + { + return m_session.EndAddNodes(result, out results, out diagnosticInfos); + } + + /// + public Task AddNodesAsync(RequestHeader requestHeader, AddNodesItemCollection nodesToAdd, CancellationToken ct) + { + using (Activity activity = ActivitySource.StartActivity(nameof(AddNodesAsync))) + { + return m_session.AddNodesAsync(requestHeader, nodesToAdd, ct); + } + } + + /// + public ResponseHeader AddReferences(RequestHeader requestHeader, AddReferencesItemCollection referencesToAdd, out StatusCodeCollection results, out DiagnosticInfoCollection diagnosticInfos) + { + using (Activity activity = ActivitySource.StartActivity(nameof(AddReferences))) + { + return m_session.AddReferences(requestHeader, referencesToAdd, out results, out diagnosticInfos); + } + } + + /// + public IAsyncResult BeginAddReferences(RequestHeader requestHeader, AddReferencesItemCollection referencesToAdd, AsyncCallback callback, object asyncState) + { + return m_session.BeginAddReferences(requestHeader, referencesToAdd, callback, asyncState); + } + + /// + public ResponseHeader EndAddReferences(IAsyncResult result, out StatusCodeCollection results, out DiagnosticInfoCollection diagnosticInfos) + { + return m_session.EndAddReferences(result, out results, out diagnosticInfos); + } + + /// + public Task AddReferencesAsync(RequestHeader requestHeader, AddReferencesItemCollection referencesToAdd, CancellationToken ct) + { + using (Activity activity = ActivitySource.StartActivity(nameof(AddReferencesAsync))) + { + return m_session.AddReferencesAsync(requestHeader, referencesToAdd, ct); + } + } + + /// + public ResponseHeader DeleteNodes(RequestHeader requestHeader, DeleteNodesItemCollection nodesToDelete, out StatusCodeCollection results, out DiagnosticInfoCollection diagnosticInfos) + { + using (Activity activity = ActivitySource.StartActivity(nameof(DeleteNodes))) + { + return m_session.DeleteNodes(requestHeader, nodesToDelete, out results, out diagnosticInfos); + } + } + + /// + public IAsyncResult BeginDeleteNodes(RequestHeader requestHeader, DeleteNodesItemCollection nodesToDelete, AsyncCallback callback, object asyncState) + { + return m_session.BeginDeleteNodes(requestHeader, nodesToDelete, callback, asyncState); + } + + /// + public ResponseHeader EndDeleteNodes(IAsyncResult result, out StatusCodeCollection results, out DiagnosticInfoCollection diagnosticInfos) + { + return m_session.EndDeleteNodes(result, out results, out diagnosticInfos); + } + + /// + public Task DeleteNodesAsync(RequestHeader requestHeader, DeleteNodesItemCollection nodesToDelete, CancellationToken ct) + { + using (Activity activity = ActivitySource.StartActivity(nameof(DeleteNodesAsync))) + { + return m_session.DeleteNodesAsync(requestHeader, nodesToDelete, ct); + } + } + + /// + public ResponseHeader DeleteReferences(RequestHeader requestHeader, DeleteReferencesItemCollection referencesToDelete, out StatusCodeCollection results, out DiagnosticInfoCollection diagnosticInfos) + { + using (Activity activity = ActivitySource.StartActivity(nameof(DeleteReferences))) + { + return m_session.DeleteReferences(requestHeader, referencesToDelete, out results, out diagnosticInfos); + } + } + + /// + public IAsyncResult BeginDeleteReferences(RequestHeader requestHeader, DeleteReferencesItemCollection referencesToDelete, AsyncCallback callback, object asyncState) + { + return m_session.BeginDeleteReferences(requestHeader, referencesToDelete, callback, asyncState); + } + + /// + public ResponseHeader EndDeleteReferences(IAsyncResult result, out StatusCodeCollection results, out DiagnosticInfoCollection diagnosticInfos) + { + return m_session.EndDeleteReferences(result, out results, out diagnosticInfos); + } + + /// + public Task DeleteReferencesAsync(RequestHeader requestHeader, DeleteReferencesItemCollection referencesToDelete, CancellationToken ct) + { + using (Activity activity = ActivitySource.StartActivity(nameof(DeleteReferencesAsync))) + { + return m_session.DeleteReferencesAsync(requestHeader, referencesToDelete, ct); + } + } + + /// + public ResponseHeader Browse(RequestHeader requestHeader, ViewDescription view, uint requestedMaxReferencesPerNode, BrowseDescriptionCollection nodesToBrowse, out BrowseResultCollection results, out DiagnosticInfoCollection diagnosticInfos) + { + using (Activity activity = ActivitySource.StartActivity(nameof(Browse))) + { + return m_session.Browse(requestHeader, view, requestedMaxReferencesPerNode, nodesToBrowse, out results, out diagnosticInfos); + } + } + + /// + public IAsyncResult BeginBrowse(RequestHeader requestHeader, ViewDescription view, uint requestedMaxReferencesPerNode, BrowseDescriptionCollection nodesToBrowse, AsyncCallback callback, object asyncState) + { + return m_session.BeginBrowse(requestHeader, view, requestedMaxReferencesPerNode, nodesToBrowse, callback, asyncState); + } + + /// + public ResponseHeader EndBrowse(IAsyncResult result, out BrowseResultCollection results, out DiagnosticInfoCollection diagnosticInfos) + { + return m_session.EndBrowse(result, out results, out diagnosticInfos); + } + + /// + public Task BrowseAsync(RequestHeader requestHeader, ViewDescription view, uint requestedMaxReferencesPerNode, BrowseDescriptionCollection nodesToBrowse, CancellationToken ct) + { + using (Activity activity = ActivitySource.StartActivity(nameof(BrowseAsync))) + { + return m_session.BrowseAsync(requestHeader, view, requestedMaxReferencesPerNode, nodesToBrowse, ct); + } + } + + /// + public ResponseHeader BrowseNext(RequestHeader requestHeader, bool releaseContinuationPoints, ByteStringCollection continuationPoints, out BrowseResultCollection results, out DiagnosticInfoCollection diagnosticInfos) + { + using (Activity activity = ActivitySource.StartActivity(nameof(BrowseNext))) + { + return m_session.BrowseNext(requestHeader, releaseContinuationPoints, continuationPoints, out results, out diagnosticInfos); + } + } + + /// + public IAsyncResult BeginBrowseNext(RequestHeader requestHeader, bool releaseContinuationPoints, ByteStringCollection continuationPoints, AsyncCallback callback, object asyncState) + { + return m_session.BeginBrowseNext(requestHeader, releaseContinuationPoints, continuationPoints, callback, asyncState); + } + + /// + public ResponseHeader EndBrowseNext(IAsyncResult result, out BrowseResultCollection results, out DiagnosticInfoCollection diagnosticInfos) + { + return m_session.EndBrowseNext(result, out results, out diagnosticInfos); + } + + /// + public Task BrowseNextAsync(RequestHeader requestHeader, bool releaseContinuationPoints, ByteStringCollection continuationPoints, CancellationToken ct) + { + using (Activity activity = ActivitySource.StartActivity(nameof(BrowseNextAsync))) + { + return m_session.BrowseNextAsync(requestHeader, releaseContinuationPoints, continuationPoints, ct); + } + } + + /// + public ResponseHeader TranslateBrowsePathsToNodeIds(RequestHeader requestHeader, BrowsePathCollection browsePaths, out BrowsePathResultCollection results, out DiagnosticInfoCollection diagnosticInfos) + { + using (Activity activity = ActivitySource.StartActivity(nameof(TranslateBrowsePathsToNodeIds))) + { + return m_session.TranslateBrowsePathsToNodeIds(requestHeader, browsePaths, out results, out diagnosticInfos); + } + } + + /// + public IAsyncResult BeginTranslateBrowsePathsToNodeIds(RequestHeader requestHeader, BrowsePathCollection browsePaths, AsyncCallback callback, object asyncState) + { + return m_session.BeginTranslateBrowsePathsToNodeIds(requestHeader, browsePaths, callback, asyncState); + } + + /// + public ResponseHeader EndTranslateBrowsePathsToNodeIds(IAsyncResult result, out BrowsePathResultCollection results, out DiagnosticInfoCollection diagnosticInfos) + { + return m_session.EndTranslateBrowsePathsToNodeIds(result, out results, out diagnosticInfos); + } + + /// + public Task TranslateBrowsePathsToNodeIdsAsync(RequestHeader requestHeader, BrowsePathCollection browsePaths, CancellationToken ct) + { + using (Activity activity = ActivitySource.StartActivity(nameof(TranslateBrowsePathsToNodeIdsAsync))) + { + return m_session.TranslateBrowsePathsToNodeIdsAsync(requestHeader, browsePaths, ct); + } + } + + /// + public ResponseHeader RegisterNodes(RequestHeader requestHeader, NodeIdCollection nodesToRegister, out NodeIdCollection registeredNodeIds) + { + using (Activity activity = ActivitySource.StartActivity(nameof(RegisterNodes))) + { + return m_session.RegisterNodes(requestHeader, nodesToRegister, out registeredNodeIds); + } + } + + /// + public IAsyncResult BeginRegisterNodes(RequestHeader requestHeader, NodeIdCollection nodesToRegister, AsyncCallback callback, object asyncState) + { + return m_session.BeginRegisterNodes(requestHeader, nodesToRegister, callback, asyncState); + } + + /// + public ResponseHeader EndRegisterNodes(IAsyncResult result, out NodeIdCollection registeredNodeIds) + { + return m_session.EndRegisterNodes(result, out registeredNodeIds); + } + + /// + public Task RegisterNodesAsync(RequestHeader requestHeader, NodeIdCollection nodesToRegister, CancellationToken ct) + { + using (Activity activity = ActivitySource.StartActivity(nameof(RegisterNodesAsync))) + { + return m_session.RegisterNodesAsync(requestHeader, nodesToRegister, ct); + } + } + + /// + public ResponseHeader UnregisterNodes(RequestHeader requestHeader, NodeIdCollection nodesToUnregister) + { + using (Activity activity = ActivitySource.StartActivity(nameof(UnregisterNodes))) + { + return m_session.UnregisterNodes(requestHeader, nodesToUnregister); + } + } + + /// + public IAsyncResult BeginUnregisterNodes(RequestHeader requestHeader, NodeIdCollection nodesToUnregister, AsyncCallback callback, object asyncState) + { + return m_session.BeginUnregisterNodes(requestHeader, nodesToUnregister, callback, asyncState); + } + + /// + public ResponseHeader EndUnregisterNodes(IAsyncResult result) + { + return m_session.EndUnregisterNodes(result); + } + + /// + public Task UnregisterNodesAsync(RequestHeader requestHeader, NodeIdCollection nodesToUnregister, CancellationToken ct) + { + using (Activity activity = ActivitySource.StartActivity(nameof(UnregisterNodesAsync))) + { + return m_session.UnregisterNodesAsync(requestHeader, nodesToUnregister, ct); + } + } + + /// + public ResponseHeader QueryFirst(RequestHeader requestHeader, ViewDescription view, NodeTypeDescriptionCollection nodeTypes, ContentFilter filter, uint maxDataSetsToReturn, uint maxReferencesToReturn, out QueryDataSetCollection queryDataSets, out byte[] continuationPoint, out ParsingResultCollection parsingResults, out DiagnosticInfoCollection diagnosticInfos, out ContentFilterResult filterResult) + { + using (Activity activity = ActivitySource.StartActivity(nameof(QueryFirst))) + { + return m_session.QueryFirst(requestHeader, view, nodeTypes, filter, maxDataSetsToReturn, maxReferencesToReturn, out queryDataSets, out continuationPoint, out parsingResults, out diagnosticInfos, out filterResult); + } + } + + /// + public IAsyncResult BeginQueryFirst(RequestHeader requestHeader, ViewDescription view, NodeTypeDescriptionCollection nodeTypes, ContentFilter filter, uint maxDataSetsToReturn, uint maxReferencesToReturn, AsyncCallback callback, object asyncState) + { + return m_session.BeginQueryFirst(requestHeader, view, nodeTypes, filter, maxDataSetsToReturn, maxReferencesToReturn, callback, asyncState); + } + + /// + public ResponseHeader EndQueryFirst(IAsyncResult result, out QueryDataSetCollection queryDataSets, out byte[] continuationPoint, out ParsingResultCollection parsingResults, out DiagnosticInfoCollection diagnosticInfos, out ContentFilterResult filterResult) + { + return m_session.EndQueryFirst(result, out queryDataSets, out continuationPoint, out parsingResults, out diagnosticInfos, out filterResult); + } + + /// + public Task QueryFirstAsync(RequestHeader requestHeader, ViewDescription view, NodeTypeDescriptionCollection nodeTypes, ContentFilter filter, uint maxDataSetsToReturn, uint maxReferencesToReturn, CancellationToken ct) + { + using (Activity activity = ActivitySource.StartActivity(nameof(QueryFirstAsync))) + { + return m_session.QueryFirstAsync(requestHeader, view, nodeTypes, filter, maxDataSetsToReturn, maxReferencesToReturn, ct); + } + } + + /// + public ResponseHeader QueryNext(RequestHeader requestHeader, bool releaseContinuationPoint, byte[] continuationPoint, out QueryDataSetCollection queryDataSets, out byte[] revisedContinuationPoint) + { + using (Activity activity = ActivitySource.StartActivity(nameof(QueryNext))) + { + return m_session.QueryNext(requestHeader, releaseContinuationPoint, continuationPoint, out queryDataSets, out revisedContinuationPoint); + } + } + + /// + public IAsyncResult BeginQueryNext(RequestHeader requestHeader, bool releaseContinuationPoint, byte[] continuationPoint, AsyncCallback callback, object asyncState) + { + return m_session.BeginQueryNext(requestHeader, releaseContinuationPoint, continuationPoint, callback, asyncState); + } + + /// + public ResponseHeader EndQueryNext(IAsyncResult result, out QueryDataSetCollection queryDataSets, out byte[] revisedContinuationPoint) + { + return m_session.EndQueryNext(result, out queryDataSets, out revisedContinuationPoint); + } + + /// + public Task QueryNextAsync(RequestHeader requestHeader, bool releaseContinuationPoint, byte[] continuationPoint, CancellationToken ct) + { + using (Activity activity = ActivitySource.StartActivity(nameof(QueryNextAsync))) + { + return m_session.QueryNextAsync(requestHeader, releaseContinuationPoint, continuationPoint, ct); + } + } + + /// + public ResponseHeader Read(RequestHeader requestHeader, double maxAge, TimestampsToReturn timestampsToReturn, ReadValueIdCollection nodesToRead, out DataValueCollection results, out DiagnosticInfoCollection diagnosticInfos) + { + using (Activity activity = ActivitySource.StartActivity(nameof(Read))) + { + return m_session.Read(requestHeader, maxAge, timestampsToReturn, nodesToRead, out results, out diagnosticInfos); + } + } + + /// + public IAsyncResult BeginRead(RequestHeader requestHeader, double maxAge, TimestampsToReturn timestampsToReturn, ReadValueIdCollection nodesToRead, AsyncCallback callback, object asyncState) + { + return m_session.BeginRead(requestHeader, maxAge, timestampsToReturn, nodesToRead, callback, asyncState); + } + + /// + public ResponseHeader EndRead(IAsyncResult result, out DataValueCollection results, out DiagnosticInfoCollection diagnosticInfos) + { + return m_session.EndRead(result, out results, out diagnosticInfos); + } + + /// + public Task ReadAsync(RequestHeader requestHeader, double maxAge, TimestampsToReturn timestampsToReturn, ReadValueIdCollection nodesToRead, CancellationToken ct) + { + using (Activity activity = ActivitySource.StartActivity(nameof(ReadAsync))) + { + return m_session.ReadAsync(requestHeader, maxAge, timestampsToReturn, nodesToRead, ct); + } + } + + /// + public ResponseHeader HistoryRead(RequestHeader requestHeader, ExtensionObject historyReadDetails, TimestampsToReturn timestampsToReturn, bool releaseContinuationPoints, HistoryReadValueIdCollection nodesToRead, out HistoryReadResultCollection results, out DiagnosticInfoCollection diagnosticInfos) + { + using (Activity activity = ActivitySource.StartActivity(nameof(HistoryRead))) + { + return m_session.HistoryRead(requestHeader, historyReadDetails, timestampsToReturn, releaseContinuationPoints, nodesToRead, out results, out diagnosticInfos); + } + } + + /// + public IAsyncResult BeginHistoryRead(RequestHeader requestHeader, ExtensionObject historyReadDetails, TimestampsToReturn timestampsToReturn, bool releaseContinuationPoints, HistoryReadValueIdCollection nodesToRead, AsyncCallback callback, object asyncState) + { + return m_session.BeginHistoryRead(requestHeader, historyReadDetails, timestampsToReturn, releaseContinuationPoints, nodesToRead, callback, asyncState); + } + + /// + public ResponseHeader EndHistoryRead(IAsyncResult result, out HistoryReadResultCollection results, out DiagnosticInfoCollection diagnosticInfos) + { + return m_session.EndHistoryRead(result, out results, out diagnosticInfos); + } + + /// + public Task HistoryReadAsync(RequestHeader requestHeader, ExtensionObject historyReadDetails, TimestampsToReturn timestampsToReturn, bool releaseContinuationPoints, HistoryReadValueIdCollection nodesToRead, CancellationToken ct) + { + using (Activity activity = ActivitySource.StartActivity(nameof(HistoryReadAsync))) + { + return m_session.HistoryReadAsync(requestHeader, historyReadDetails, timestampsToReturn, releaseContinuationPoints, nodesToRead, ct); + } + } + + /// + public ResponseHeader Write(RequestHeader requestHeader, WriteValueCollection nodesToWrite, out StatusCodeCollection results, out DiagnosticInfoCollection diagnosticInfos) + { + using (Activity activity = ActivitySource.StartActivity(nameof(Write))) + { + return m_session.Write(requestHeader, nodesToWrite, out results, out diagnosticInfos); + } + } + + /// + public IAsyncResult BeginWrite(RequestHeader requestHeader, WriteValueCollection nodesToWrite, AsyncCallback callback, object asyncState) + { + return m_session.BeginWrite(requestHeader, nodesToWrite, callback, asyncState); + } + + /// + public ResponseHeader EndWrite(IAsyncResult result, out StatusCodeCollection results, out DiagnosticInfoCollection diagnosticInfos) + { + return m_session.EndWrite(result, out results, out diagnosticInfos); + } + + /// + public Task WriteAsync(RequestHeader requestHeader, WriteValueCollection nodesToWrite, CancellationToken ct) + { + using (Activity activity = ActivitySource.StartActivity(nameof(WriteAsync))) + { + return m_session.WriteAsync(requestHeader, nodesToWrite, ct); + } + } + + /// + public ResponseHeader HistoryUpdate(RequestHeader requestHeader, ExtensionObjectCollection historyUpdateDetails, out HistoryUpdateResultCollection results, out DiagnosticInfoCollection diagnosticInfos) + { + using (Activity activity = ActivitySource.StartActivity(nameof(HistoryUpdate))) + { + return m_session.HistoryUpdate(requestHeader, historyUpdateDetails, out results, out diagnosticInfos); + } + } + + /// + public IAsyncResult BeginHistoryUpdate(RequestHeader requestHeader, ExtensionObjectCollection historyUpdateDetails, AsyncCallback callback, object asyncState) + { + return m_session.BeginHistoryUpdate(requestHeader, historyUpdateDetails, callback, asyncState); + } + + /// + public ResponseHeader EndHistoryUpdate(IAsyncResult result, out HistoryUpdateResultCollection results, out DiagnosticInfoCollection diagnosticInfos) + { + return m_session.EndHistoryUpdate(result, out results, out diagnosticInfos); + } + + /// + public Task HistoryUpdateAsync(RequestHeader requestHeader, ExtensionObjectCollection historyUpdateDetails, CancellationToken ct) + { + using (Activity activity = ActivitySource.StartActivity(nameof(HistoryUpdateAsync))) + { + return m_session.HistoryUpdateAsync(requestHeader, historyUpdateDetails, ct); + } + } + + /// + public ResponseHeader Call(RequestHeader requestHeader, CallMethodRequestCollection methodsToCall, out CallMethodResultCollection results, out DiagnosticInfoCollection diagnosticInfos) + { + using (Activity activity = ActivitySource.StartActivity(nameof(Call))) + { + return m_session.Call(requestHeader, methodsToCall, out results, out diagnosticInfos); + } + } + + /// + public IAsyncResult BeginCall(RequestHeader requestHeader, CallMethodRequestCollection methodsToCall, AsyncCallback callback, object asyncState) + { + return m_session.BeginCall(requestHeader, methodsToCall, callback, asyncState); + } + + /// + public ResponseHeader EndCall(IAsyncResult result, out CallMethodResultCollection results, out DiagnosticInfoCollection diagnosticInfos) + { + return m_session.EndCall(result, out results, out diagnosticInfos); + } + + /// + public Task CallAsync(RequestHeader requestHeader, CallMethodRequestCollection methodsToCall, CancellationToken ct) + { + using (Activity activity = ActivitySource.StartActivity(nameof(CallAsync))) + { + return m_session.CallAsync(requestHeader, methodsToCall, ct); + } + } + + /// + public ResponseHeader CreateMonitoredItems(RequestHeader requestHeader, uint subscriptionId, TimestampsToReturn timestampsToReturn, MonitoredItemCreateRequestCollection itemsToCreate, out MonitoredItemCreateResultCollection results, out DiagnosticInfoCollection diagnosticInfos) + { + using (Activity activity = ActivitySource.StartActivity(nameof(CreateMonitoredItems))) + { + return m_session.CreateMonitoredItems(requestHeader, subscriptionId, timestampsToReturn, itemsToCreate, out results, out diagnosticInfos); + } + } + + /// + public IAsyncResult BeginCreateMonitoredItems(RequestHeader requestHeader, uint subscriptionId, TimestampsToReturn timestampsToReturn, MonitoredItemCreateRequestCollection itemsToCreate, AsyncCallback callback, object asyncState) + { + return m_session.BeginCreateMonitoredItems(requestHeader, subscriptionId, timestampsToReturn, itemsToCreate, callback, asyncState); + } + + /// + public ResponseHeader EndCreateMonitoredItems(IAsyncResult result, out MonitoredItemCreateResultCollection results, out DiagnosticInfoCollection diagnosticInfos) + { + return m_session.EndCreateMonitoredItems(result, out results, out diagnosticInfos); + } + + /// + public Task CreateMonitoredItemsAsync(RequestHeader requestHeader, uint subscriptionId, TimestampsToReturn timestampsToReturn, MonitoredItemCreateRequestCollection itemsToCreate, CancellationToken ct) + { + using (Activity activity = ActivitySource.StartActivity(nameof(CreateMonitoredItemsAsync))) + { + return m_session.CreateMonitoredItemsAsync(requestHeader, subscriptionId, timestampsToReturn, itemsToCreate, ct); + } + } + + /// + public ResponseHeader ModifyMonitoredItems(RequestHeader requestHeader, uint subscriptionId, TimestampsToReturn timestampsToReturn, MonitoredItemModifyRequestCollection itemsToModify, out MonitoredItemModifyResultCollection results, out DiagnosticInfoCollection diagnosticInfos) + { + using (Activity activity = ActivitySource.StartActivity(nameof(ModifyMonitoredItems))) + { + return m_session.ModifyMonitoredItems(requestHeader, subscriptionId, timestampsToReturn, itemsToModify, out results, out diagnosticInfos); + } + } + + /// + public IAsyncResult BeginModifyMonitoredItems(RequestHeader requestHeader, uint subscriptionId, TimestampsToReturn timestampsToReturn, MonitoredItemModifyRequestCollection itemsToModify, AsyncCallback callback, object asyncState) + { + return m_session.BeginModifyMonitoredItems(requestHeader, subscriptionId, timestampsToReturn, itemsToModify, callback, asyncState); + } + + /// + public ResponseHeader EndModifyMonitoredItems(IAsyncResult result, out MonitoredItemModifyResultCollection results, out DiagnosticInfoCollection diagnosticInfos) + { + return m_session.EndModifyMonitoredItems(result, out results, out diagnosticInfos); + } + + /// + public Task ModifyMonitoredItemsAsync(RequestHeader requestHeader, uint subscriptionId, TimestampsToReturn timestampsToReturn, MonitoredItemModifyRequestCollection itemsToModify, CancellationToken ct) + { + using (Activity activity = ActivitySource.StartActivity(nameof(ModifyMonitoredItemsAsync))) + { + return m_session.ModifyMonitoredItemsAsync(requestHeader, subscriptionId, timestampsToReturn, itemsToModify, ct); + } + } + + /// + public ResponseHeader SetMonitoringMode(RequestHeader requestHeader, uint subscriptionId, MonitoringMode monitoringMode, UInt32Collection monitoredItemIds, out StatusCodeCollection results, out DiagnosticInfoCollection diagnosticInfos) + { + using (Activity activity = ActivitySource.StartActivity(nameof(SetMonitoringMode))) + { + return m_session.SetMonitoringMode(requestHeader, subscriptionId, monitoringMode, monitoredItemIds, out results, out diagnosticInfos); + } + } + + /// + public IAsyncResult BeginSetMonitoringMode(RequestHeader requestHeader, uint subscriptionId, MonitoringMode monitoringMode, UInt32Collection monitoredItemIds, AsyncCallback callback, object asyncState) + { + return m_session.BeginSetMonitoringMode(requestHeader, subscriptionId, monitoringMode, monitoredItemIds, callback, asyncState); + } + + /// + public ResponseHeader EndSetMonitoringMode(IAsyncResult result, out StatusCodeCollection results, out DiagnosticInfoCollection diagnosticInfos) + { + return m_session.EndSetMonitoringMode(result, out results, out diagnosticInfos); + } + + /// + public Task SetMonitoringModeAsync(RequestHeader requestHeader, uint subscriptionId, MonitoringMode monitoringMode, UInt32Collection monitoredItemIds, CancellationToken ct) + { + using (Activity activity = ActivitySource.StartActivity(nameof(SetMonitoringModeAsync))) + { + return m_session.SetMonitoringModeAsync(requestHeader, subscriptionId, monitoringMode, monitoredItemIds, ct); + } + } + + /// + public ResponseHeader SetTriggering(RequestHeader requestHeader, uint subscriptionId, uint triggeringItemId, UInt32Collection linksToAdd, UInt32Collection linksToRemove, out StatusCodeCollection addResults, out DiagnosticInfoCollection addDiagnosticInfos, out StatusCodeCollection removeResults, out DiagnosticInfoCollection removeDiagnosticInfos) + { + using (Activity activity = ActivitySource.StartActivity(nameof(SetTriggering))) + { + return m_session.SetTriggering(requestHeader, subscriptionId, triggeringItemId, linksToAdd, linksToRemove, out addResults, out addDiagnosticInfos, out removeResults, out removeDiagnosticInfos); + } + } + + /// + public IAsyncResult BeginSetTriggering(RequestHeader requestHeader, uint subscriptionId, uint triggeringItemId, UInt32Collection linksToAdd, UInt32Collection linksToRemove, AsyncCallback callback, object asyncState) + { + return m_session.BeginSetTriggering(requestHeader, subscriptionId, triggeringItemId, linksToAdd, linksToRemove, callback, asyncState); + } + + /// + public ResponseHeader EndSetTriggering(IAsyncResult result, out StatusCodeCollection addResults, out DiagnosticInfoCollection addDiagnosticInfos, out StatusCodeCollection removeResults, out DiagnosticInfoCollection removeDiagnosticInfos) + { + return m_session.EndSetTriggering(result, out addResults, out addDiagnosticInfos, out removeResults, out removeDiagnosticInfos); + } + + /// + public Task SetTriggeringAsync(RequestHeader requestHeader, uint subscriptionId, uint triggeringItemId, UInt32Collection linksToAdd, UInt32Collection linksToRemove, CancellationToken ct) + { + using (Activity activity = ActivitySource.StartActivity(nameof(SetTriggeringAsync))) + { + return m_session.SetTriggeringAsync(requestHeader, subscriptionId, triggeringItemId, linksToAdd, linksToRemove, ct); + } + } + + /// + public ResponseHeader DeleteMonitoredItems(RequestHeader requestHeader, uint subscriptionId, UInt32Collection monitoredItemIds, out StatusCodeCollection results, out DiagnosticInfoCollection diagnosticInfos) + { + using (Activity activity = ActivitySource.StartActivity(nameof(DeleteMonitoredItems))) + { + return m_session.DeleteMonitoredItems(requestHeader, subscriptionId, monitoredItemIds, out results, out diagnosticInfos); + } + } + + /// + public IAsyncResult BeginDeleteMonitoredItems(RequestHeader requestHeader, uint subscriptionId, UInt32Collection monitoredItemIds, AsyncCallback callback, object asyncState) + { + return m_session.BeginDeleteMonitoredItems(requestHeader, subscriptionId, monitoredItemIds, callback, asyncState); + } + + /// + public ResponseHeader EndDeleteMonitoredItems(IAsyncResult result, out StatusCodeCollection results, out DiagnosticInfoCollection diagnosticInfos) + { + return m_session.EndDeleteMonitoredItems(result, out results, out diagnosticInfos); + } + + /// + public Task DeleteMonitoredItemsAsync(RequestHeader requestHeader, uint subscriptionId, UInt32Collection monitoredItemIds, CancellationToken ct) + { + using (Activity activity = ActivitySource.StartActivity(nameof(DeleteMonitoredItemsAsync))) + { + return m_session.DeleteMonitoredItemsAsync(requestHeader, subscriptionId, monitoredItemIds, ct); + } + } + + /// + public ResponseHeader CreateSubscription(RequestHeader requestHeader, double requestedPublishingInterval, uint requestedLifetimeCount, uint requestedMaxKeepAliveCount, uint maxNotificationsPerPublish, bool publishingEnabled, byte priority, out uint subscriptionId, out double revisedPublishingInterval, out uint revisedLifetimeCount, out uint revisedMaxKeepAliveCount) + { + using (Activity activity = ActivitySource.StartActivity(nameof(CreateSubscription))) + { + return m_session.CreateSubscription(requestHeader, requestedPublishingInterval, requestedLifetimeCount, requestedMaxKeepAliveCount, maxNotificationsPerPublish, publishingEnabled, priority, out subscriptionId, out revisedPublishingInterval, out revisedLifetimeCount, out revisedMaxKeepAliveCount); + } + } + + /// + public IAsyncResult BeginCreateSubscription(RequestHeader requestHeader, double requestedPublishingInterval, uint requestedLifetimeCount, uint requestedMaxKeepAliveCount, uint maxNotificationsPerPublish, bool publishingEnabled, byte priority, AsyncCallback callback, object asyncState) + { + return m_session.BeginCreateSubscription(requestHeader, requestedPublishingInterval, requestedLifetimeCount, requestedMaxKeepAliveCount, maxNotificationsPerPublish, publishingEnabled, priority, callback, asyncState); + } + + /// + public ResponseHeader EndCreateSubscription(IAsyncResult result, out uint subscriptionId, out double revisedPublishingInterval, out uint revisedLifetimeCount, out uint revisedMaxKeepAliveCount) + { + return m_session.EndCreateSubscription(result, out subscriptionId, out revisedPublishingInterval, out revisedLifetimeCount, out revisedMaxKeepAliveCount); + } + + /// + public Task CreateSubscriptionAsync(RequestHeader requestHeader, double requestedPublishingInterval, uint requestedLifetimeCount, uint requestedMaxKeepAliveCount, uint maxNotificationsPerPublish, bool publishingEnabled, byte priority, CancellationToken ct) + { + using (Activity activity = ActivitySource.StartActivity(nameof(CreateSubscriptionAsync))) + { + return m_session.CreateSubscriptionAsync(requestHeader, requestedPublishingInterval, requestedLifetimeCount, requestedMaxKeepAliveCount, maxNotificationsPerPublish, publishingEnabled, priority, ct); + } + } + + /// + public ResponseHeader ModifySubscription(RequestHeader requestHeader, uint subscriptionId, double requestedPublishingInterval, uint requestedLifetimeCount, uint requestedMaxKeepAliveCount, uint maxNotificationsPerPublish, byte priority, out double revisedPublishingInterval, out uint revisedLifetimeCount, out uint revisedMaxKeepAliveCount) + { + using (Activity activity = ActivitySource.StartActivity(nameof(ModifySubscription))) + { + return m_session.ModifySubscription(requestHeader, subscriptionId, requestedPublishingInterval, requestedLifetimeCount, requestedMaxKeepAliveCount, maxNotificationsPerPublish, priority, out revisedPublishingInterval, out revisedLifetimeCount, out revisedMaxKeepAliveCount); + } + } + + /// + public IAsyncResult BeginModifySubscription(RequestHeader requestHeader, uint subscriptionId, double requestedPublishingInterval, uint requestedLifetimeCount, uint requestedMaxKeepAliveCount, uint maxNotificationsPerPublish, byte priority, AsyncCallback callback, object asyncState) + { + return m_session.BeginModifySubscription(requestHeader, subscriptionId, requestedPublishingInterval, requestedLifetimeCount, requestedMaxKeepAliveCount, maxNotificationsPerPublish, priority, callback, asyncState); + } + + /// + public ResponseHeader EndModifySubscription(IAsyncResult result, out double revisedPublishingInterval, out uint revisedLifetimeCount, out uint revisedMaxKeepAliveCount) + { + return m_session.EndModifySubscription(result, out revisedPublishingInterval, out revisedLifetimeCount, out revisedMaxKeepAliveCount); + } + + /// + public Task ModifySubscriptionAsync(RequestHeader requestHeader, uint subscriptionId, double requestedPublishingInterval, uint requestedLifetimeCount, uint requestedMaxKeepAliveCount, uint maxNotificationsPerPublish, byte priority, CancellationToken ct) + { + using (Activity activity = ActivitySource.StartActivity(nameof(ModifySubscriptionAsync))) + { + return m_session.ModifySubscriptionAsync(requestHeader, subscriptionId, requestedPublishingInterval, requestedLifetimeCount, requestedMaxKeepAliveCount, maxNotificationsPerPublish, priority, ct); + } + } + + /// + public ResponseHeader SetPublishingMode(RequestHeader requestHeader, bool publishingEnabled, UInt32Collection subscriptionIds, out StatusCodeCollection results, out DiagnosticInfoCollection diagnosticInfos) + { + using (Activity activity = ActivitySource.StartActivity(nameof(SetPublishingMode))) + { + return m_session.SetPublishingMode(requestHeader, publishingEnabled, subscriptionIds, out results, out diagnosticInfos); + } + } + + /// + public IAsyncResult BeginSetPublishingMode(RequestHeader requestHeader, bool publishingEnabled, UInt32Collection subscriptionIds, AsyncCallback callback, object asyncState) + { + return m_session.BeginSetPublishingMode(requestHeader, publishingEnabled, subscriptionIds, callback, asyncState); + } + + /// + public ResponseHeader EndSetPublishingMode(IAsyncResult result, out StatusCodeCollection results, out DiagnosticInfoCollection diagnosticInfos) + { + return m_session.EndSetPublishingMode(result, out results, out diagnosticInfos); + } + + /// + public Task SetPublishingModeAsync(RequestHeader requestHeader, bool publishingEnabled, UInt32Collection subscriptionIds, CancellationToken ct) + { + using (Activity activity = ActivitySource.StartActivity(nameof(SetPublishingModeAsync))) + { + return m_session.SetPublishingModeAsync(requestHeader, publishingEnabled, subscriptionIds, ct); + } + } + + /// + public ResponseHeader Publish(RequestHeader requestHeader, SubscriptionAcknowledgementCollection subscriptionAcknowledgements, out uint subscriptionId, out UInt32Collection availableSequenceNumbers, out bool moreNotifications, out NotificationMessage notificationMessage, out StatusCodeCollection results, out DiagnosticInfoCollection diagnosticInfos) + { + using (Activity activity = ActivitySource.StartActivity(nameof(Publish))) + { + return m_session.Publish(requestHeader, subscriptionAcknowledgements, out subscriptionId, out availableSequenceNumbers, out moreNotifications, out notificationMessage, out results, out diagnosticInfos); + } + } + + /// + public IAsyncResult BeginPublish(RequestHeader requestHeader, SubscriptionAcknowledgementCollection subscriptionAcknowledgements, AsyncCallback callback, object asyncState) + { + return m_session.BeginPublish(requestHeader, subscriptionAcknowledgements, callback, asyncState); + } + + /// + public ResponseHeader EndPublish(IAsyncResult result, out uint subscriptionId, out UInt32Collection availableSequenceNumbers, out bool moreNotifications, out NotificationMessage notificationMessage, out StatusCodeCollection results, out DiagnosticInfoCollection diagnosticInfos) + { + return m_session.EndPublish(result, out subscriptionId, out availableSequenceNumbers, out moreNotifications, out notificationMessage, out results, out diagnosticInfos); + } + + /// + public Task PublishAsync(RequestHeader requestHeader, SubscriptionAcknowledgementCollection subscriptionAcknowledgements, CancellationToken ct) + { + using (Activity activity = ActivitySource.StartActivity(nameof(PublishAsync))) + { + return m_session.PublishAsync(requestHeader, subscriptionAcknowledgements, ct); + } + } + + /// + public ResponseHeader Republish(RequestHeader requestHeader, uint subscriptionId, uint retransmitSequenceNumber, out NotificationMessage notificationMessage) + { + using (Activity activity = ActivitySource.StartActivity(nameof(Republish))) + { + return m_session.Republish(requestHeader, subscriptionId, retransmitSequenceNumber, out notificationMessage); + } + } + + /// + public IAsyncResult BeginRepublish(RequestHeader requestHeader, uint subscriptionId, uint retransmitSequenceNumber, AsyncCallback callback, object asyncState) + { + return m_session.BeginRepublish(requestHeader, subscriptionId, retransmitSequenceNumber, callback, asyncState); + } + + /// + public ResponseHeader EndRepublish(IAsyncResult result, out NotificationMessage notificationMessage) + { + return m_session.EndRepublish(result, out notificationMessage); + } + + /// + public Task RepublishAsync(RequestHeader requestHeader, uint subscriptionId, uint retransmitSequenceNumber, CancellationToken ct) + { + using (Activity activity = ActivitySource.StartActivity(nameof(RepublishAsync))) + { + return m_session.RepublishAsync(requestHeader, subscriptionId, retransmitSequenceNumber, ct); + } + } + + /// + public ResponseHeader TransferSubscriptions(RequestHeader requestHeader, UInt32Collection subscriptionIds, bool sendInitialValues, out TransferResultCollection results, out DiagnosticInfoCollection diagnosticInfos) + { + using (Activity activity = ActivitySource.StartActivity(nameof(TransferSubscriptions))) + { + return m_session.TransferSubscriptions(requestHeader, subscriptionIds, sendInitialValues, out results, out diagnosticInfos); + } + } + + /// + public IAsyncResult BeginTransferSubscriptions(RequestHeader requestHeader, UInt32Collection subscriptionIds, bool sendInitialValues, AsyncCallback callback, object asyncState) + { + return m_session.BeginTransferSubscriptions(requestHeader, subscriptionIds, sendInitialValues, callback, asyncState); + } + + /// + public ResponseHeader EndTransferSubscriptions(IAsyncResult result, out TransferResultCollection results, out DiagnosticInfoCollection diagnosticInfos) + { + return m_session.EndTransferSubscriptions(result, out results, out diagnosticInfos); + } + + /// + public Task TransferSubscriptionsAsync(RequestHeader requestHeader, UInt32Collection subscriptionIds, bool sendInitialValues, CancellationToken ct) + { + using (Activity activity = ActivitySource.StartActivity(nameof(TransferSubscriptionsAsync))) + { + return m_session.TransferSubscriptionsAsync(requestHeader, subscriptionIds, sendInitialValues, ct); + } + } + + /// + public ResponseHeader DeleteSubscriptions(RequestHeader requestHeader, UInt32Collection subscriptionIds, out StatusCodeCollection results, out DiagnosticInfoCollection diagnosticInfos) + { + using (Activity activity = ActivitySource.StartActivity(nameof(DeleteSubscriptions))) + { + return m_session.DeleteSubscriptions(requestHeader, subscriptionIds, out results, out diagnosticInfos); + } + } + + /// + public IAsyncResult BeginDeleteSubscriptions(RequestHeader requestHeader, UInt32Collection subscriptionIds, AsyncCallback callback, object asyncState) + { + return m_session.BeginDeleteSubscriptions(requestHeader, subscriptionIds, callback, asyncState); + } + + /// + public ResponseHeader EndDeleteSubscriptions(IAsyncResult result, out StatusCodeCollection results, out DiagnosticInfoCollection diagnosticInfos) + { + return m_session.EndDeleteSubscriptions(result, out results, out diagnosticInfos); + } + + /// + public Task DeleteSubscriptionsAsync(RequestHeader requestHeader, UInt32Collection subscriptionIds, CancellationToken ct) + { + using (Activity activity = ActivitySource.StartActivity(nameof(DeleteSubscriptionsAsync))) + { + return m_session.DeleteSubscriptionsAsync(requestHeader, subscriptionIds, ct); + } + } + + /// + public void AttachChannel(ITransportChannel channel) + { + using (Activity activity = ActivitySource.StartActivity(nameof(AttachChannel))) + { + m_session.AttachChannel(channel); + } + } + + /// + public void DetachChannel() + { + using (Activity activity = ActivitySource.StartActivity(nameof(DetachChannel))) + { + m_session.DetachChannel(); + } + } + + /// + public StatusCode Close() + { + using (Activity activity = ActivitySource.StartActivity(nameof(Close))) + { + return m_session.Close(); + } + } + + /// + public uint NewRequestHandle() + { + return m_session.NewRequestHandle(); + } + + /// + /// Disposes the session. + /// + protected virtual void Dispose(bool disposing) + { + m_session.Dispose(); + m_session = null; + } + + /// + public void Dispose() + { + // Do not change this code. Put cleanup code in 'Dispose(bool disposing)' method + Dispose(disposing: true); + GC.SuppressFinalize(this); + } + + /// + public SessionConfiguration SaveSessionConfiguration(Stream stream = null) + { + using (Activity activity = ActivitySource.StartActivity(nameof(SaveSessionConfiguration))) + { + return m_session.SaveSessionConfiguration(stream); + } + } + + /// + public bool ApplySessionConfiguration(SessionConfiguration sessionConfiguration) + { + using (Activity activity = ActivitySource.StartActivity(nameof(ApplySessionConfiguration))) + { + return m_session.ApplySessionConfiguration(sessionConfiguration); + } + } + + /// + public bool ReactivateSubscriptions(SubscriptionCollection subscriptions, bool sendInitialValues) + { + using (Activity activity = ActivitySource.StartActivity(nameof(ReactivateSubscriptions))) + { + return m_session.ReactivateSubscriptions(subscriptions, sendInitialValues); + } + } + + /// + public Task RemoveSubscriptionAsync(Subscription subscription, CancellationToken ct = default) + { + using (Activity activity = ActivitySource.StartActivity(nameof(RemoveSubscriptionAsync))) + { + return m_session.RemoveSubscriptionAsync(subscription, ct); + } + } + + /// + public Task RemoveSubscriptionsAsync(IEnumerable subscriptions, CancellationToken ct = default) + { + using (Activity activity = ActivitySource.StartActivity(nameof(RemoveSubscriptionsAsync))) + { + return m_session.RemoveSubscriptionsAsync(subscriptions, ct); + } + } + + /// + public Task ReactivateSubscriptionsAsync(SubscriptionCollection subscriptions, bool sendInitialValues, CancellationToken ct = default) + { + using (Activity activity = ActivitySource.StartActivity(nameof(ReactivateSubscriptionsAsync))) + { + return m_session.ReactivateSubscriptionsAsync(subscriptions, sendInitialValues, ct); + } + } + + /// + public Task TransferSubscriptionsAsync(SubscriptionCollection subscriptions, bool sendInitialValues, CancellationToken ct = default) + { + using (Activity activity = ActivitySource.StartActivity(nameof(TransferSubscriptionsAsync))) + { + return m_session.TransferSubscriptionsAsync(subscriptions, sendInitialValues, ct); + } + } + + /// + public Task> CallAsync(NodeId objectId, NodeId methodId, CancellationToken ct = default, params object[] args) + { + using (Activity activity = ActivitySource.StartActivity(nameof(CallAsync))) + { + return m_session.CallAsync(objectId, methodId, ct, args); + } + } + + /// + public bool ResendData(IEnumerable subscriptions, out IList errors) + { + using (Activity activity = ActivitySource.StartActivity(nameof(ResendData))) + { + return m_session.ResendData(subscriptions, out errors); + } + } + + /// + public Task<(bool, IList)> ResendDataAsync(IEnumerable subscriptions, CancellationToken ct = default) + { + using (Activity activity = ActivitySource.StartActivity(nameof(ResendDataAsync))) + { + return m_session.ResendDataAsync(subscriptions, ct); + } + } + #endregion + } +} +#endif diff --git a/Libraries/Opc.Ua.Client/TraceableSessionFactory.cs b/Libraries/Opc.Ua.Client/TraceableSessionFactory.cs new file mode 100644 index 000000000..b501f0fd4 --- /dev/null +++ b/Libraries/Opc.Ua.Client/TraceableSessionFactory.cs @@ -0,0 +1,216 @@ +/* ======================================================================== + * Copyright (c) 2005-2023 The OPC Foundation, Inc. All rights reserved. + * + * OPC Foundation MIT License 1.00 + * + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software and associated documentation + * files (the "Software"), to deal in the Software without + * restriction, including without limitation the rights to use, + * copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following + * conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES + * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT + * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + * + * The complete license agreement can be found here: + * http://opcfoundation.org/License/MIT/1.00/ + * ======================================================================*/ + +#if NET6_0_OR_GREATER +using System; +using System.Collections.Generic; +using System.Diagnostics; +using System.Security.Cryptography.X509Certificates; +using System.Threading; +using System.Threading.Tasks; + +namespace Opc.Ua.Client +{ + /// + /// Object that creates instances of an Opc.Ua.Client.Session object with Activity Source. + /// + public class TraceableSessionFactory : DefaultSessionFactory + { + /// + /// The default instance of the factory. + /// + public new static readonly TraceableSessionFactory Instance = new TraceableSessionFactory(); + + /// + /// Force use of the default instance. + /// + protected TraceableSessionFactory() + { + } + + #region Public Methods + /// + public override async Task CreateAsync( + ApplicationConfiguration configuration, + ConfiguredEndpoint endpoint, + bool updateBeforeConnect, + string sessionName, + uint sessionTimeout, + IUserIdentity identity, + IList preferredLocales) + { + using (Activity activity = TraceableSession.ActivitySource.StartActivity(nameof(CreateAsync))) + { + ISession session = await Session.Create(configuration, endpoint, updateBeforeConnect, false, + sessionName, sessionTimeout, identity, preferredLocales).ConfigureAwait(false); + + return new TraceableSession(session); + } + } + + /// + public override async Task CreateAsync( + ApplicationConfiguration configuration, + ConfiguredEndpoint endpoint, + bool updateBeforeConnect, + bool checkDomain, + string sessionName, + uint sessionTimeout, + IUserIdentity identity, + IList preferredLocales) + { + using (Activity activity = TraceableSession.ActivitySource.StartActivity(nameof(CreateAsync))) + { + ISession session = await Session.Create(configuration, null, endpoint, + updateBeforeConnect, checkDomain, sessionName, sessionTimeout, + identity, preferredLocales).ConfigureAwait(false); + + return new TraceableSession(session); + } + } + + /// + public override async Task CreateAsync( + ApplicationConfiguration configuration, + ITransportWaitingConnection connection, + ConfiguredEndpoint endpoint, + bool updateBeforeConnect, + bool checkDomain, + string sessionName, + uint sessionTimeout, + IUserIdentity identity, + IList preferredLocales) + { + using (Activity activity = TraceableSession.ActivitySource.StartActivity(nameof(CreateAsync))) + { + ISession session = await Session.Create(configuration, connection, endpoint, + updateBeforeConnect, checkDomain, sessionName, sessionTimeout, + identity, preferredLocales + ).ConfigureAwait(false); + + return new TraceableSession(session); + } + } + + /// + public override ISession Create( + ApplicationConfiguration configuration, + ITransportChannel channel, + ConfiguredEndpoint endpoint, + X509Certificate2 clientCertificate, + EndpointDescriptionCollection availableEndpoints = null, + StringCollection discoveryProfileUris = null) + { + using (Activity activity = TraceableSession.ActivitySource.StartActivity(nameof(CreateAsync))) + { + return new TraceableSession(base.Create(configuration, channel, endpoint, clientCertificate, availableEndpoints, discoveryProfileUris)); + } + } + + /// + public override Task CreateChannelAsync(ApplicationConfiguration configuration, ITransportWaitingConnection connection, ConfiguredEndpoint endpoint, bool updateBeforeConnect, bool checkDomain) + { + using (Activity activity = TraceableSession.ActivitySource.StartActivity(nameof(CreateAsync))) + { + return base.CreateChannelAsync(configuration, connection, endpoint, updateBeforeConnect, checkDomain); + } + } + + /// + public override async Task CreateAsync( + ApplicationConfiguration configuration, + ReverseConnectManager reverseConnectManager, + ConfiguredEndpoint endpoint, + bool updateBeforeConnect, + bool checkDomain, + string sessionName, + uint sessionTimeout, + IUserIdentity userIdentity, + IList preferredLocales, + CancellationToken ct = default + ) + { + using (Activity activity = TraceableSession.ActivitySource.StartActivity(nameof(CreateAsync))) + { + ISession session = await base.CreateAsync(configuration, + reverseConnectManager, endpoint, + updateBeforeConnect, + checkDomain, sessionName, + sessionTimeout, userIdentity, + preferredLocales, ct).ConfigureAwait(false); + + return new TraceableSession(session); + } + } + + /// + public override Task RecreateAsync(ISession sessionTemplate) + { + if (!(sessionTemplate is Session session)) + { + if (sessionTemplate is TraceableSession template) + { + session = (Session)template.Session; + } + else + { + throw new ArgumentOutOfRangeException(nameof(sessionTemplate), "The ISession provided is not of a supported type."); + } + } + + using (Activity activity = TraceableSession.ActivitySource.StartActivity(nameof(RecreateAsync))) + { + return base.RecreateAsync(session); + } + } + + /// + public override Task RecreateAsync(ISession sessionTemplate, ITransportWaitingConnection connection) + { + if (!(sessionTemplate is Session session)) + { + if (sessionTemplate is TraceableSession template) + { + session = (Session)template.Session; + } + else + { + throw new ArgumentOutOfRangeException(nameof(sessionTemplate), "The ISession provided is not of a supported type."); + } + } + + using (Activity activity = TraceableSession.ActivitySource.StartActivity(nameof(RecreateAsync))) + { + return base.RecreateAsync(session, connection); + } + } + #endregion + } +} +#endif diff --git a/Libraries/Opc.Ua.Gds.Client.Common/GlobalDiscoveryServerClient.cs b/Libraries/Opc.Ua.Gds.Client.Common/GlobalDiscoveryServerClient.cs index 8fdd482e2..1e3916da6 100644 --- a/Libraries/Opc.Ua.Gds.Client.Common/GlobalDiscoveryServerClient.cs +++ b/Libraries/Opc.Ua.Gds.Client.Common/GlobalDiscoveryServerClient.cs @@ -58,7 +58,7 @@ public GlobalDiscoveryServerClient( { Configuration = configuration; EndpointUrl = endpointUrl; - m_sessionFactory = sessionFactory ?? new DefaultSessionFactory(); + m_sessionFactory = sessionFactory ?? DefaultSessionFactory.Instance; // preset admin AdminCredentials = adminUserIdentity; } diff --git a/Libraries/Opc.Ua.Gds.Client.Common/ServerPushConfigurationClient.cs b/Libraries/Opc.Ua.Gds.Client.Common/ServerPushConfigurationClient.cs index 087386ac2..e3986d835 100644 --- a/Libraries/Opc.Ua.Gds.Client.Common/ServerPushConfigurationClient.cs +++ b/Libraries/Opc.Ua.Gds.Client.Common/ServerPushConfigurationClient.cs @@ -53,7 +53,7 @@ public class ServerPushConfigurationClient public ServerPushConfigurationClient(ApplicationConfiguration configuration, ISessionFactory sessionFactory = null) { m_configuration = configuration; - m_sessionFactory = sessionFactory ?? new DefaultSessionFactory(); + m_sessionFactory = sessionFactory ?? DefaultSessionFactory.Instance; } #endregion diff --git a/Tests/Opc.Ua.Client.ComplexTypes.Tests/TypeSystemClientTest.cs b/Tests/Opc.Ua.Client.ComplexTypes.Tests/TypeSystemClientTest.cs index ff9e49c7e..b65da6fd4 100644 --- a/Tests/Opc.Ua.Client.ComplexTypes.Tests/TypeSystemClientTest.cs +++ b/Tests/Opc.Ua.Client.ComplexTypes.Tests/TypeSystemClientTest.cs @@ -29,6 +29,7 @@ using System; using System.Collections.Generic; +using System.Diagnostics; using System.IO; using System.Linq; using System.Threading; @@ -292,6 +293,7 @@ public async Task ReadWriteScalaVariableType() Value = dataWriteValue } }; + WriteResponse response = await m_session.WriteAsync(null, writeValues, CancellationToken.None).ConfigureAwait(false); Assert.NotNull(response); Assert.NotNull(response.Results); diff --git a/Tests/Opc.Ua.Client.Tests/ClientFixture.cs b/Tests/Opc.Ua.Client.Tests/ClientFixture.cs index a11b86678..0dd5fed8b 100644 --- a/Tests/Opc.Ua.Client.Tests/ClientFixture.cs +++ b/Tests/Opc.Ua.Client.Tests/ClientFixture.cs @@ -30,6 +30,7 @@ using System; using System.Collections; using System.Collections.Generic; +using System.Diagnostics; using System.IO; using System.Linq; using System.Threading.Tasks; @@ -55,7 +56,15 @@ public class ClientFixture public int OperationTimeout { get; set; } = 10000; public int TraceMasks { get; set; } = Utils.TraceMasks.Error | Utils.TraceMasks.StackTrace | Utils.TraceMasks.Security | Utils.TraceMasks.Information; - public ISessionFactory SessionFactory { get; } = new DefaultSessionFactory(); +#if NET6_0_OR_GREATER + public bool UseTracing { get; set; } = true; + + public ISessionFactory SessionFactory => UseTracing ? TraceableSessionFactory.Instance : DefaultSessionFactory.Instance; + + private ActivityListener activityListener; +#else + public ISessionFactory SessionFactory {get;} = DefaultSessionFactory.Instance; +#endif #region Public Methods /// @@ -63,6 +72,9 @@ public class ClientFixture /// public async Task LoadClientConfiguration(string pkiRoot = null, string clientName = "TestClient") { +#if NET6_0_OR_GREATER + ConfigureActivityListener(); +#endif ApplicationInstance application = new ApplicationInstance { ApplicationName = clientName }; @@ -223,7 +235,7 @@ public async Task ConnectAsync(ConfiguredEndpoint endpoint, IUserIdent /// public async Task CreateChannelAsync(ConfiguredEndpoint endpoint, bool updateBeforeConnect = true) { - return await Session.CreateChannelAsync(Config, null, endpoint, updateBeforeConnect, checkDomain: false).ConfigureAwait(false); + return await SessionFactory.CreateChannelAsync(Config, null, endpoint, updateBeforeConnect, checkDomain: false).ConfigureAwait(false); } /// @@ -232,9 +244,9 @@ public async Task CreateChannelAsync(ConfiguredEndpoint endpo /// The channel to use /// The configured endpoint /// - public Session CreateSession(ITransportChannel channel, ConfiguredEndpoint endpoint) + public ISession CreateSession(ITransportChannel channel, ConfiguredEndpoint endpoint) { - return Session.Create(Config, channel, endpoint, null); + return SessionFactory.Create(Config, channel, endpoint, null); } /// @@ -333,7 +345,14 @@ public void SetTraceOutput(TextWriter writer) m_traceLogger.SetWriter(writer); } } - #endregion + +#if NET6_0_OR_GREATER + public void Cleanup() + { + activityListener = null; + } +#endif +#endregion #region Private Methods private void Session_KeepAlive(ISession session, KeepAliveEventArgs e) @@ -343,6 +362,36 @@ private void Session_KeepAlive(ISession session, KeepAliveEventArgs e) session?.Dispose(); } } - #endregion + +#if NET6_0_OR_GREATER + /// + /// Configures Activity Listener. + /// + private void ConfigureActivityListener(bool shouldListenToAllSources = true, bool shouldWriteStartAndStop = true) + { + // Create an instance of ActivityListener and configure its properties + activityListener = new ActivityListener() + { + // Set ShouldListenTo property to true for all activity sources + ShouldListenTo = (source) => true, + + // Sample all data and recorded activities + Sample = (ref ActivityCreationOptions options) => ActivitySamplingResult.AllDataAndRecorded, + + // Write "Started" message when an activity starts + ActivityStarted = shouldWriteStartAndStop + ? activity => Console.WriteLine("Started: {0,-15} {1,-60}", activity.OperationName, activity.Id) + : (Action)(_ => { }), + + // Write "Stopped" message along with OperationName, Id, and Duration when an activity stops + ActivityStopped = shouldWriteStartAndStop + ? activity => Console.WriteLine(activity.OperationName + " : " + activity.Id + ", Duration : " + activity.Duration) + : (Action)(_ => { }), + }; + + ActivitySource.AddActivityListener(activityListener); + } +#endif +#endregion } } diff --git a/Tests/Opc.Ua.Client.Tests/ClientTest.cs b/Tests/Opc.Ua.Client.Tests/ClientTest.cs index eed2c9803..d621621a2 100644 --- a/Tests/Opc.Ua.Client.Tests/ClientTest.cs +++ b/Tests/Opc.Ua.Client.Tests/ClientTest.cs @@ -601,7 +601,7 @@ public async Task ReconnectSessionOnAlternateChannelWithSavedSessionSecrets(stri } // the active channel - Session session1 = await ClientFixture.ConnectAsync(endpoint, userIdentity).ConfigureAwait(false) as Session; + ISession session1 = await ClientFixture.ConnectAsync(endpoint, userIdentity).ConfigureAwait(false); Assert.NotNull(session1); ServerStatusDataType value1 = (ServerStatusDataType)session1.ReadValue(VariableIds.Server_ServerStatus, typeof(ServerStatusDataType)); @@ -624,7 +624,7 @@ public async Task ReconnectSessionOnAlternateChannelWithSavedSessionSecrets(stri Assert.NotNull(channel2); // prepare the inactive session with the new channel - Session session2 = ClientFixture.CreateSession(channel2, sessionConfiguration.ConfiguredEndpoint); + ISession session2 = ClientFixture.CreateSession(channel2, sessionConfiguration.ConfiguredEndpoint); // apply the saved session configuration bool success = session2.ApplySessionConfiguration(sessionConfiguration); @@ -657,6 +657,14 @@ public async Task ReconnectSessionOnAlternateChannelWithSavedSessionSecrets(stri var result = session1.ReadValue(VariableIds.Server_ServerStatus, typeof(ServerStatusDataType)); Assert.NotNull(result); } + + session1.DeleteSubscriptionsOnClose = true; + session1.Close(1000); + Utils.SilentDispose(session1); + + session2.DeleteSubscriptionsOnClose = true; + session2.Close(1000); + Utils.SilentDispose(session2); } [Test, Order(300)] diff --git a/Tests/Opc.Ua.Client.Tests/SubscriptionTest.cs b/Tests/Opc.Ua.Client.Tests/SubscriptionTest.cs index 545fe0203..ddbd7e816 100644 --- a/Tests/Opc.Ua.Client.Tests/SubscriptionTest.cs +++ b/Tests/Opc.Ua.Client.Tests/SubscriptionTest.cs @@ -474,7 +474,7 @@ public async Task ReconnectWithSavedSessionSecrets( } // the active channel - Session session1 = await ClientFixture.ConnectAsync(endpoint, userIdentity).ConfigureAwait(false) as Session; + ISession session1 = await ClientFixture.ConnectAsync(endpoint, userIdentity).ConfigureAwait(false); Assert.NotNull(session1); ServerStatusDataType value1 = (ServerStatusDataType)session1.ReadValue(VariableIds.Server_ServerStatus, typeof(ServerStatusDataType)); @@ -524,7 +524,7 @@ public async Task ReconnectWithSavedSessionSecrets( Assert.NotNull(channel2); // prepare the inactive session with the new channel - Session session2 = ClientFixture.CreateSession(channel2, sessionConfiguration.ConfiguredEndpoint); + ISession session2 = ClientFixture.CreateSession(channel2, sessionConfiguration.ConfiguredEndpoint); // apply the saved session configuration bool success = session2.ApplySessionConfiguration(sessionConfiguration); @@ -627,11 +627,11 @@ public async Task ReconnectWithSavedSessionSecrets( session1.DeleteSubscriptionsOnClose = true; session1.Close(1000); - session1.Dispose(); + Utils.SilentDispose(session1); session2.DeleteSubscriptionsOnClose = true; session2.Close(1000); - session2.Dispose(); + Utils.SilentDispose(session2); } [Test, Order(400)]