/// <summary>
/// Invokes the _NAME_ service using async Task based request.
/// </summary>
    void AsyncCall()
    {
        _NAME_Request  request  = new _NAME_Request();
        _NAME_Response response = null;

        // RequestParameters

        UpdateRequestHeader(request, requestHeader == null, "_NAME_");

        try
        {
            IServiceResponse genericResponse = await TransportChannel.SendRequestAsync(request, ct).ConfigureAwait(false);

            if (genericResponse == null)
            {
                throw new ServiceResultException(StatusCodes.BadUnknownResponse);
            }

            ValidateResponse(genericResponse.ResponseHeader);
            response = (_NAME_Response)genericResponse;
        }
        finally
        {
            RequestCompleted(request, response, "_NAME_");
        }

        return(response);
    }
/// <summary>
/// Finishes an asynchronous invocation of the _NAME_ service.
/// </summary>
    void EndAsyncCall()
    {
        _NAME_Response response = null;

        try
        {
            IServiceResponse genericResponse = TransportChannel.EndSendRequest(result);

            if (genericResponse == null)
            {
                throw new ServiceResultException(StatusCodes.BadUnknownResponse);
            }

            ValidateResponse(genericResponse.ResponseHeader);
            response = (_NAME_Response)genericResponse;

            // ResponseParameters
        }
        finally
        {
            RequestCompleted(null, response, "_NAME_");
        }

        return(response.ResponseHeader);
    }
        public void Dispose()
        {
            if (IsConnected)
            {
                try
                {
                    IsConnected = false;
                    Logger.NetChannelIsDisposing(Node, this);

                    _onDisconnectedSubject.OnNext(this);
                    _onDisconnectedSubject.OnCompleted();
                    _onOperationSubject.OnCompleted();

                    OnDisconnected();

                    foreach (var pendingOperation in PendingOperationsByRequestId)
                    {
                        try
                        {
                            if (!pendingOperation.Value.TCS.Task.IsCompleted)
                            {
                                pendingOperation.Value.TCS.SetException(
                                    new OperationCanceledException("netChannel was closed"));
                            }
                        }
                        catch {}
                    }
                }
                finally
                {
                    TransportChannel.Dispose();
                }
            }
        }
/// <summary>
/// Begins an asynchronous invocation of the _NAME_ service.
/// </summary>
    void BeginAsyncCall()
    {
        _NAME_Request request = new _NAME_Request();

        // RequestParameters

        UpdateRequestHeader(request, requestHeader == null, "_NAME_");

        return(TransportChannel.BeginSendRequest(request, callback, asyncState));
    }
예제 #5
0
/// <summary>
/// Begins an asynchronous invocation of the _NAME_ service.
/// </summary>
    void BeginAsyncCall()
    {
        _NAME_Request request = new _NAME_Request();

        // RequestParameters

        UpdateRequestHeader(request, requestHeader == null, "_NAME_");

        if (UseTransportChannel)
        {
            return(TransportChannel.BeginSendRequest(request, callback, asyncState));
        }

        return(InnerChannel.Begin_NAME_(new _NAME_Message(request), callback, asyncState));
    }
예제 #6
0
// ***START***
    #region _NAME_ Methods
#if (!OPCUA_EXCLUDE__NAME_)
/// <summary>
/// Invokes the _NAME_ service.
/// </summary>
    void SyncCall()
    {
        _NAME_Request  request  = new _NAME_Request();
        _NAME_Response response = null;

        // RequestParameters

        UpdateRequestHeader(request, requestHeader == null, "_NAME_");

        try
        {
            if (UseTransportChannel)
            {
                IServiceResponse genericResponse = TransportChannel.SendRequest(request);

                if (genericResponse == null)
                {
                    throw new ServiceResultException(StatusCodes.BadUnknownResponse);
                }

                ValidateResponse(genericResponse.ResponseHeader);
                response = (_NAME_Response)genericResponse;
            }
            else
            {
                _NAME_ResponseMessage responseMessage = InnerChannel._NAME_(new _NAME_Message(request));

                if (responseMessage == null || responseMessage._NAME_Response == null)
                {
                    throw new ServiceResultException(StatusCodes.BadUnknownResponse);
                }

                response = responseMessage._NAME_Response;
                ValidateResponse(response.ResponseHeader);
            }

            // ResponseParameters
        }
        finally
        {
            RequestCompleted(request, response, "_NAME_");
        }

        return(response.ResponseHeader);
    }
        public void Send(Message msg)
        {
            _sentMessagesMeter.Mark();
            var buffer = _bufferPool.Take(_config.MaxMessageSizeBts);

            try
            {
                using (var stream = new MemoryStream(buffer))
                {
                    MessageSerializer.Serialize(msg, stream);
                    TransportChannel.Send(msg.Priority, msg.Reliability, new ArraySegment <byte>(buffer, 0, (int)stream.Position));
                }

                Logger.NetChannelSentMessage(Node, this, msg);
            }
            finally
            {
                _bufferPool.Return(buffer);
            }
        }
예제 #8
0
 public AudioClientFeature(TransportDriver driver, TransportChannel channel)
 {
     Driver           = driver;
     PreferredChannel = channel;
 }
예제 #9
0
 internal SocketWriter(TransportChannel outer)
 {
     this.outer = outer;
 }