SendCCancelRequest Method (DicomNet)

Sends a C-CANCEL-REQ message to a peer member of a connection.

Syntax

C#
Visual Basic
WinRT C#
Objective-C
Java
WinRT JavaScript
C++

public void SendCCancelRequest( 
   byte presentationID,
   int messageID
)

'Declaration

Public Sub SendCCancelRequest( _
   ByVal presentationID As Byte, _
   ByVal messageID As Integer _
)

'Usage

Dim instance As DicomNet
Dim presentationID As Byte
Dim messageID As Integer
 
instance.SendCCancelRequest(presentationID, messageID)

public void SendCCancelRequest( 
   byte presentationID,
   int messageID
)

 function Leadtools.Dicom.DicomNet.SendCCancelRequest( 
   presentationID ,
   messageID 
)

public:
void SendCCancelRequest( 
   byte presentationID,
   int messageID
)

Parameters

presentationID: The Presentation Context ID. The ID provides information about both the class type of the data and the Transfer Syntax to use when transferring the data.
messageID: The Message ID. Each message sent by a member of a connection should have a unique ID. Since a member of a connection may send several messages, this ID allows that member to identify when a specific request has been completed.

Remarks

Calling this method generates a call to OnReceiveCCancelRequest on the SCP.

Example

This is a comprehensive sample that shows how to process a DICOM C-Cancel operation on both the SCP (server) and the SCU (client) sides.

C#
Visual Basic
WinRT C#
WinRT JavaScript
Silverlight C#
Silverlight VB

Copy Code

Imports Leadtools
Imports Leadtools.Dicom

<StructLayout(LayoutKind.Sequential)> _
Public Structure MSG
    Public hwnd As IntPtr
    Public message As UInteger
    Public wParam As IntPtr
    Public lParam As IntPtr
    Public time As UInteger
    Public p As System.Drawing.Point
End Structure
Public Enum WaitReturn
    Complete
    Timeout
End Enum

Private Class Utils
 <DllImport("user32.dll")> _
 Shared Function PeekMessage(<System.Runtime.InteropServices.Out()> ByRef lpMsg As MSG, ByVal hWnd As IntPtr, ByVal wMsgFilterMin As UInteger, _
                                ByVal wMsgFilterMax As UInteger, ByVal wRemoveMsg As UInteger) As <MarshalAs(UnmanagedType.Bool)> Boolean
 End Function

    <DllImport("user32.dll")> _
    Shared Function TranslateMessage(ByRef lpMsg As MSG) As Boolean
    End Function
    <DllImport("user32.dll")> _
    Shared Function DispatchMessage(ByRef lpmsg As MSG) As IntPtr
    End Function

    Private Const PM_REMOVE As UInteger = 1

    Public Shared Function WaitForComplete(ByVal mill As Double, ByVal wh As WaitHandle) As WaitReturn
        Dim goal As TimeSpan = New TimeSpan(DateTime.Now.AddMilliseconds(mill).Ticks)

        Do
            Dim msg As MSG = New MSG()

            If PeekMessage(msg, IntPtr.Zero, 0, 0, PM_REMOVE) Then
                TranslateMessage(msg)
                DispatchMessage(msg)
            End If

            If wh.WaitOne(New TimeSpan(0, 0, 0), False) Then
                Return WaitReturn.Complete
            End If

            If goal.CompareTo(New TimeSpan(DateTime.Now.Ticks)) < 0 Then
                Return WaitReturn.Timeout
            End If

        Loop While True
    End Function
End Class

Private Class Client : Inherits DicomNet
    Private _LastError As DicomExceptionCode = DicomExceptionCode.Success
    Private waitEvent As AutoResetEvent = New AutoResetEvent(False)

    Public Sub New()
        MyBase.New(Nothing, DicomNetSecurityeMode.None)
    End Sub

    Public ReadOnly Property LastError() As DicomExceptionCode
        Get
            Return _LastError
        End Get
    End Property

    Public Function Wait() As Boolean
        Dim ret As WaitReturn

        _LastError = DicomExceptionCode.Success
        ret = Utils.WaitForComplete((5 * 60) * 1000, waitEvent)

        Return (ret = WaitReturn.Complete)
    End Function

    Protected Overrides Sub OnConnect(ByVal [error] As DicomExceptionCode)
        _LastError = [error]
        waitEvent.Set()
    End Sub

    Protected Overrides Sub OnReceiveAssociateAccept(ByVal association As DicomAssociate)
        waitEvent.Set()
    End Sub

    Protected Overrides Sub OnClose(ByVal [error] As DicomExceptionCode, ByVal net As DicomNet)
        waitEvent.Set()
    End Sub
End Class

Private Class ServerConnection : Inherits DicomNet
    Public Sub New()
        MyBase.New(Nothing, DicomNetSecurityeMode.None)
    End Sub

    Protected Overrides Sub OnReceiveAssociateRequest(ByVal association As DicomAssociate)
        Dim retAssociation As DicomAssociate = New DicomAssociate(False)

        Debug.Assert(association.Called = "ServerTest", "Called AETitle should be ServerTest")
        Debug.Assert(association.Calling = "ClientTest", "Calling AETitle should be ClientTest")
        Debug.Assert(association.ImplementClass = "1.2.840.114257.1", "Implementation class should be 1.2.840.114257.1")
        Debug.Assert(association.ImplementationVersionName = "1", "Implementation version should be 1")
        Debug.Assert(association.MaxLength = &H100000, "Max length should be 0x100000")
        Debug.Assert(association.GetAbstract(1) = DicomUidType.VerificationClass, "Presentation index 1 should be " & DicomUidType.VerificationClass)
        Debug.Assert(association.GetTransfer(1, 0) = DicomUidType.ImplicitVRLittleEndian, "Abstract Syntax (1,0) should be " & DicomUidType.ImplicitVRLittleEndian)

        '
        ' Build our Association Accept
        '
        retAssociation.Called = association.Called
        retAssociation.Calling = association.Calling
        retAssociation.ImplementClass = association.ImplementClass
        retAssociation.ImplementationVersionName = association.ImplementationVersionName
        Dim x As Integer = 0
        Do While x < association.PresentationContextCount
            Dim id As Byte = association.GetPresentationContextID(x)
            Dim abSyntax As String = association.GetAbstract(id)
            Dim trSyntax As String = DicomUidType.ImplicitVRLittleEndian

            retAssociation.AddPresentationContext(id, 0, abSyntax)
            If association.GetTransferCount(id) > 0 Then
                trSyntax = association.GetTransfer(id, 0)
            End If

            retAssociation.AddTransfer(id, trSyntax)
            x += 1
        Loop
        SendAssociateAccept(retAssociation)
    End Sub

    Protected Overrides Sub OnReceiveCCancelRequest(ByVal presentationID As Byte, ByVal messageID As Integer)
        Debug.Assert(presentationID = 1, "Presentation ID should be 1")
        Debug.Assert(messageID = 1, "Message ID should be 1")
        Close()
    End Sub
End Class

Private Class Server : Inherits DicomNet
    Private client As ServerConnection

    Public Sub New()
        MyBase.New(Nothing, DicomNetSecurityeMode.None)
    End Sub

    Protected Overrides Sub OnAccept(ByVal [error] As DicomExceptionCode)
        client = New ServerConnection()

        Accept(client)
    End Sub
End Class


<TestMethod()> _
Public Sub SendCCancleRequestSample()
    DicomEngine.Startup()
    DicomNet.Startup()

    Using server As Server = New Server()
        Using client As Client = New Client()
            '
            ' Connect to server
            '
            server.Listen("127.0.0.1", 104, 1) ' start server
            client.Connect(Nothing, 1000, "127.0.0.1", 104) ' connect to server
            If (Not client.Wait()) Then ' wait for connection to finish
                Debug.Fail("Connection timed out")
            End If
            Debug.Assert(client.LastError = DicomExceptionCode.Success, "Connection failed")
            Debug.Assert(client.IsConnected(), "Client not connected")

            '
            ' Send associate request
            '
            Dim associate As DicomAssociate = New DicomAssociate(True)

            associate.Called = "ServerTest"
            associate.Calling = "ClientTest"
            associate.ImplementClass = "1.2.840.114257.1"
            associate.ImplementationVersionName = "1"
            associate.MaxLength = &H100000
            associate.AddPresentationContext(1, 0, DicomUidType.VerificationClass)
            associate.AddTransfer(1, DicomUidType.ImplicitVRLittleEndian)
            client.SendAssociateRequest(associate)
            If (Not client.Wait()) Then ' wait for connection to finish
                Debug.Fail("SendAssociateRequest timed out")
            End If

            Dim p As IntPtr = New IntPtr(5)
            client.SendCCancelRequest(1, 1)
            If (Not client.Wait()) Then ' wait for SendNonSecureISCL to finish
                Debug.Fail("SendCCancelRequest timed out")
            End If
            If client.IsConnected() Then
                client.CloseForced(True)
            End If
        End Using
        server.CloseForced(True)
    End Using

    DicomEngine.Shutdown()
    DicomNet.Shutdown()
End Sub

using Leadtools;
using Leadtools.Dicom;

[StructLayout(LayoutKind.Sequential)]
public struct MSG
{
    public IntPtr hwnd;
    public uint message;
    public IntPtr wParam;
    public IntPtr lParam;
    public uint time;
    public System.Drawing.Point p;
}
public enum WaitReturn
{
    Complete,
    Timeout,
}

class Utils
{
    [DllImport("user32.dll")]
    [return: MarshalAs(UnmanagedType.Bool)]
    static extern bool PeekMessage(out MSG lpMsg, IntPtr hWnd,
                                   uint wMsgFilterMin, uint wMsgFilterMax,
                                   uint wRemoveMsg);

    [DllImport("user32.dll")]
    static extern bool TranslateMessage([In] ref MSG lpMsg);
    [DllImport("user32.dll")]
    static extern IntPtr DispatchMessage([In] ref MSG lpmsg);

    const uint PM_REMOVE = 1;

    public static WaitReturn WaitForComplete(double mill, WaitHandle wh)
    {
        TimeSpan goal = new TimeSpan(DateTime.Now.AddMilliseconds(mill).Ticks);

        do
        {
            MSG msg = new MSG();

            if (PeekMessage(out msg, IntPtr.Zero, 0, 0, PM_REMOVE))
            {
                TranslateMessage(ref msg);
                DispatchMessage(ref msg);
            }

            if (wh.WaitOne(new TimeSpan(0, 0, 0), false))
            {
                return WaitReturn.Complete;
            }

            if (goal.CompareTo(new TimeSpan(DateTime.Now.Ticks)) < 0)
            {
                return WaitReturn.Timeout;
            }

        } while (true);
    }
}

class Client : DicomNet
{
    DicomExceptionCode _LastError = DicomExceptionCode.Success;
    AutoResetEvent waitEvent = new AutoResetEvent(false);

    public Client()
        : base(null, DicomNetSecurityeMode.None)
    {
    }

    public DicomExceptionCode LastError
    {
        get
        {
            return _LastError;
        }
    }

    public bool Wait()
    {
        WaitReturn ret;

        _LastError = DicomExceptionCode.Success;
        ret = Utils.WaitForComplete((5 * 60) * 1000, waitEvent);

        return (ret == WaitReturn.Complete);
    }

    protected override void OnConnect(DicomExceptionCode error)
    {
        _LastError = error;
        waitEvent.Set();
    }

    protected override void OnReceiveAssociateAccept(DicomAssociate association)
    {
        waitEvent.Set();
    }

    protected override void OnClose(DicomExceptionCode error, DicomNet net)
    {               
        waitEvent.Set();
    }
}

class ServerConnection : DicomNet
{
    public ServerConnection()
        : base(null, DicomNetSecurityeMode.None)
    {
    }

    protected override void OnReceiveAssociateRequest(DicomAssociate association)
    {
        DicomAssociate retAssociation = new DicomAssociate(false);

        Debug.Assert(association.Called == "ServerTest", "Called AETitle should be ServerTest");
        Debug.Assert(association.Calling == "ClientTest", "Calling AETitle should be ClientTest");
        Debug.Assert(association.ImplementClass == "1.2.840.114257.1", "Implementation class should be 1.2.840.114257.1");
        Debug.Assert(association.ImplementationVersionName == "1", "Implementation version should be 1");
        Debug.Assert(association.MaxLength == 0x100000, "Max length should be 0x100000");
        Debug.Assert(association.GetAbstract(1) == DicomUidType.VerificationClass, "Presentation index 1 should be " + DicomUidType.VerificationClass);
        Debug.Assert(association.GetTransfer(1, 0) == DicomUidType.ImplicitVRLittleEndian, "Abstract Syntax (1,0) should be " + DicomUidType.ImplicitVRLittleEndian);

        //
        // Build our Association Accept
        //

        retAssociation.Called = association.Called;
        retAssociation.Calling = association.Calling;
        retAssociation.ImplementClass = association.ImplementClass;
        retAssociation.ImplementationVersionName = association.ImplementationVersionName;
        for (int x = 0; x < association.PresentationContextCount; x++)
        {
            byte id = association.GetPresentationContextID(x);
            string abSyntax = association.GetAbstract(id);
            string trSyntax = DicomUidType.ImplicitVRLittleEndian;

            retAssociation.AddPresentationContext(id, 0, abSyntax);
            if (association.GetTransferCount(id) > 0)
            {
                trSyntax = association.GetTransfer(id, 0);
            }

            retAssociation.AddTransfer(id, trSyntax);
        }
        SendAssociateAccept(retAssociation);
    }

    protected override void OnReceiveCCancelRequest(byte presentationID, int messageID)
    {                
        Debug.Assert(presentationID == 1, "Presentation ID should be 1");
        Debug.Assert(messageID == 1, "Message ID should be 1");
        Close();
    }
}

class Server : DicomNet
{
    ServerConnection client;

    public Server()
        : base(null, DicomNetSecurityeMode.None)
    {
    }

    protected override void OnAccept(DicomExceptionCode error)
    {
        client = new ServerConnection();

        Accept(client);
    }
}

[TestMethod]
public void SendCCancleRequestSample()
{
    DicomEngine.Startup();
    DicomNet.Startup();

    using (Server server = new Server())
    {
        using (Client client = new Client())
        {
            //
            // Connect to server
            //

            server.Listen("127.0.0.1", 104, 1); // start server
            client.Connect(null, 1000, "127.0.0.1", 104); // connect to server
            if (!client.Wait()) // wait for connection to finish
            {
                Debug.Fail("Connection timed out");
            }
            Debug.Assert(client.LastError == DicomExceptionCode.Success, "Connection failed");
            Debug.Assert(client.IsConnected(), "Client not connected");

            //
            // Send associate request
            //

            DicomAssociate associate = new DicomAssociate(true);

            associate.Called = "ServerTest";
            associate.Calling = "ClientTest";
            associate.ImplementClass = "1.2.840.114257.1";
            associate.ImplementationVersionName = "1";
            associate.MaxLength = 0x100000;
            associate.AddPresentationContext(1, 0, DicomUidType.VerificationClass);
            associate.AddTransfer(1, DicomUidType.ImplicitVRLittleEndian);
            client.SendAssociateRequest(associate);
            if (!client.Wait()) // wait for connection to finish
            {
                Debug.Fail("SendAssociateRequest timed out");
            }

            IntPtr p = new IntPtr(5);
            client.SendCCancelRequest(1, 1);
            if (!client.Wait()) // wait for SendNonSecureISCL to finish
            {
                Debug.Fail("SendCCancelRequest timed out");
            }
            if (client.IsConnected())
                client.CloseForced(true); 
        }
        server.CloseForced(true);
    }

    DicomEngine.Shutdown();
    DicomNet.Shutdown();
}

using Leadtools;
using Leadtools.Dicom;
using Leadtools.Dicom.Networking;

public enum WaitReturn
{
    Complete,
    Timeout,
}
class Utils
{
    public static WaitReturn WaitForComplete(int ms, WaitHandle wh)
    {
        TimeSpan goal = new TimeSpan(DateTime.Now.AddMilliseconds(ms).Ticks);

        do
        {

            if (wh.WaitOne(ms))
            {
                return WaitReturn.Complete;
            }

            if (goal.CompareTo(new TimeSpan(DateTime.Now.Ticks)) < 0)
            {
                return WaitReturn.Timeout;
            }

        } while (true);
    }
}

class Client : IDicomEvents
{
    public DicomNet net;
    DicomExceptionCode _LastError = DicomExceptionCode.Success;
    AutoResetEvent waitEvent = new AutoResetEvent(false);

    public Client()
    {
        net = new DicomNet(string.Empty, this);
    }

    public DicomExceptionCode LastError
    {
        get
        {
            return _LastError;
        }
    }

    public bool Wait()
    {
        WaitReturn ret;

        _LastError = DicomExceptionCode.Success;
        ret = Utils.WaitForComplete((5) * 1000, waitEvent);

        return (ret == WaitReturn.Complete);
    }

    public void OnConnect(DicomExceptionCode error, DicomNet net)
    {
        Debug.WriteLine("Client::OnConnect");
        _LastError = error;
        waitEvent.Set();
    }

    public void OnReceiveAssociateAccept(DicomAssociate association, DicomNet net)
    {
        Debug.WriteLine("Client::OnReceiveAssociateAccept");
        waitEvent.Set();
    }

    public void OnClose(DicomExceptionCode error, DicomNet net)
    {
        Debug.WriteLine("Client::OnClose");
        waitEvent.Set();
    }

    public void OnAccept(DicomExceptionCode error, DicomNet net, object hHandle)
    {
        // Not Used
    }

    public void OnReceive(DicomExceptionCode error, DicomPduType type, byte[] buffer, DicomNet net)
    {
        // Not Used
    }

    public void OnReceiveAbort(DicomAbortSourceType source, DicomAbortReasonType reason, DicomNet net)
    {
        // Not Used
    }

    public void OnReceiveAssociateReject(DicomAssociateRejectResultType result, DicomAssociateRejectSourceType source, DicomAssociateRejectReasonType reason, DicomNet net)
    {
        // Not Used
    }

    public void OnReceiveAssociateRequest(DicomAssociate association, DicomNet net)
    {
        // Not Used
    }

    public void OnReceiveCCancelRequest(byte presentationId, ushort messageId, DicomNet net)
    {
        // Not Used
    }

    public void OnReceiveCEchoRequest(byte presentationId, ushort messageId, string affectedClass, DicomNet net)
    {
        // Not Used
    }

    public void OnReceiveCEchoResponse(byte presentationId, ushort messageId, string affectedClass, DicomCommandStatusType status, DicomNet net)
    {
        // Not Used
    }

    public void OnReceiveCFindRequest(byte presentationId, ushort messageId, string affectedClass, DicomCommandPriorityType priority, DicomDataSet dataset, DicomNet net)
    {
        // Not Used
    }

    public void OnReceiveCFindResponse(byte presentationId, ushort messageId, string affectedClass, DicomCommandStatusType status, DicomDataSet dataset, DicomNet net)
    {
        // Not Used
    }

    public void OnReceiveCGetRequest(byte presentationId, ushort messageId, string affectedClass, DicomCommandPriorityType priority, DicomDataSet dataset, DicomNet net)
    {
        // Not Used
    }

    public void OnReceiveCGetResponse(byte presentationId, ushort messageId, string affectedClass, DicomCommandStatusType status, ushort remaining, ushort completed, ushort failed, ushort warning, DicomDataSet dataset, DicomNet net)
    {
        // Not Used
    }

    public void OnReceiveCMoveRequest(byte presentationId, ushort messageId, string affectedClass, DicomCommandPriorityType priority, string MoveAE, DicomDataSet dataset, DicomNet net)
    {
        // Not Used
    }

    public void OnReceiveCMoveResponse(byte presentationId, ushort messageId, string affectedClass, DicomCommandStatusType status, ushort remaining, ushort completed, ushort failed, ushort warning, DicomDataSet dataset, DicomNet net)
    {
        // Not Used
    }

    public void OnReceiveCStoreRequest(byte presentationId, ushort messageId, string affectedClass, string Instance, DicomCommandPriorityType priority, string MoveAE, ushort moveMessageId, DicomDataSet dataset, DicomNet net)
    {
        // Not Used
    }

    public void OnReceiveCStoreResponse(byte presentationId, ushort messageId, string affectedClass, string Instance, DicomCommandStatusType status, DicomNet net)
    {
        // Not Used
    }

    public void OnReceiveData(byte presentationId, DicomDataSet commandset, DicomDataSet dataset, DicomNet net)
    {
        // Not Used
    }

    public void OnReceiveNActionRequest(byte presentationId, ushort messageId, string affectedClass, string Instance, ushort action, DicomDataSet dataset, DicomNet net)
    {
        // Not Used
    }

    public void OnReceiveNActionResponse(byte presentationId, ushort messageId, string affectedClass, string Instance, DicomCommandStatusType status, ushort action, DicomDataSet dataset, DicomNet net)
    {
        // Not Used
    }

    public void OnReceiveNCreateRequest(byte presentationId, ushort messageId, string affectedClass, string Instance, DicomDataSet dataset, DicomNet net)
    {
        // Not Used
    }

    public void OnReceiveNCreateResponse(byte presentationId, ushort messageId, string affectedClass, string Instance, DicomCommandStatusType status, DicomDataSet dataset, DicomNet net)
    {
        // Not Used
    }

    public void OnReceiveNDeleteRequest(byte presentationId, ushort messageId, string affectedClass, string Instance, DicomNet net)
    {
        // Not Used
    }

    public void OnReceiveNDeleteResponse(byte presentationId, ushort messageId, string affectedClass, string Instance, DicomCommandStatusType status, DicomNet net)
    {
        // Not Used
    }

    public void OnReceiveNGetRequest(byte presentationID, ushort messageID, string affectedClass, string instance, uint[] attributes, DicomNet net)
    {
        // Not Used
    }

    public void OnReceiveNGetResponse(byte presentationId, ushort messageId, string affectedClass, string Instance, DicomCommandStatusType status, DicomDataSet dataset, DicomNet net)
    {
        // Not Used
    }

    public void OnReceiveNReportRequest(byte presentationId, ushort messageId, string affectedClass, string Instance, ushort dicomevent, DicomDataSet dataset, DicomNet net)
    {
        // Not Used
    }

    public void OnReceiveNReportResponse(byte presentationId, ushort messageId, string affectedClass, string Instance, DicomCommandStatusType status, ushort dicomevent, DicomDataSet dataset, DicomNet net)
    {
        // Not Used
    }

    public void OnReceiveNSetRequest(byte presentationId, ushort messageId, string affectedClass, string Instance, DicomDataSet dataset, DicomNet net)
    {
        // Not Used
    }

    public void OnReceiveNSetResponse(byte presentationId, ushort messageId, string affectedClass, string Instance, DicomCommandStatusType status, DicomDataSet dataset, DicomNet net)
    {
        // Not Used
    }

    public void OnReceiveReleaseRequest(DicomNet net)
    {
        // Not Used
    }

    public void OnReceiveReleaseResponse(DicomNet net)
    {
        // Not Used
    }

    public void OnReceiveUnknown(byte presentationId, DicomDataSet commandset, DicomDataSet dataset, DicomNet net)
    {
        // Not Used
    }

    public void OnSend(DicomExceptionCode error, DicomPduType type, uint bytes, DicomNet net)
    {
        // Not Used
    }
}

class ServerConnection : IDicomEvents
{
    public DicomNet net;

    public ServerConnection()
    {
        net = new DicomNet(string.Empty, this);
    }

    public void OnReceiveAssociateRequest(DicomAssociate association, DicomNet net)
    {
        Debug.WriteLine("ServerConnection::OnReceiveAssociateRequest");
        DicomAssociate retAssociation = new DicomAssociate(false);

        Debug.Assert(association.Called == "ServerTest", "Called AETitle should be ServerTest");
        Debug.Assert(association.Calling == "ClientTest", "Calling AETitle should be ClientTest");
        Debug.Assert(association.ImplementClass == "1.2.840.114257.1", "Implementation class should be 1.2.840.114257.1");
        Debug.Assert(association.ImplementationVersionName == "1", "Implementation version should be 1");
        Debug.Assert(association.MaxLength == 0x100000, "Max length should be 0x100000");
        Debug.Assert(association.GetAbstract(1) == DicomUidType.VerificationClass, "Presentation index 1 should be " + DicomUidType.VerificationClass);
        Debug.Assert(association.GetTransfer(1, 0) == DicomUidType.ImplicitVRLittleEndian, "Abstract Syntax (1,0) should be " + DicomUidType.ImplicitVRLittleEndian);

        //
        // Build our Association Accept
        //

        retAssociation.Called = association.Called;
        retAssociation.Calling = association.Calling;
        retAssociation.ImplementClass = association.ImplementClass;
        retAssociation.ImplementationVersionName = association.ImplementationVersionName;
        for (int x = 0; x < association.PresentationContextCount; x++)
        {
            byte id = association.GetPresentationContextID(x);
            string abSyntax = association.GetAbstract(id);
            string trSyntax = DicomUidType.ImplicitVRLittleEndian;

            retAssociation.AddPresentationContext(id, 0, abSyntax);
            if (association.GetTransferCount(id) > 0)
            {
                trSyntax = association.GetTransfer(id, 0);
            }

            retAssociation.AddTransfer(id, trSyntax);
        }

        Debug.WriteLine("ServerConnection::SendAssociateAccept");
        net.SendAssociateAccept(retAssociation);
    }

    public void OnReceiveCCancelRequest(byte presentationID, int messageID, DicomNet net)
    {                
        Debug.Assert(presentationID == 1, "Presentation ID should be 1");
        Debug.Assert(messageID == 1, "Message ID should be 1");
        net.Close();
    }

    public void OnAccept(DicomExceptionCode error, DicomNet net, object hHandle)
    {
        // Not Used
    }

    public void OnClose(DicomExceptionCode error, DicomNet net)
    {
        // Not Used
    }

    public void OnConnect(DicomExceptionCode error, DicomNet net)
    {
        // Not Used
    }

    public void OnReceive(DicomExceptionCode error, DicomPduType type, byte[] buffer, DicomNet net)
    {
        // Not Used
    }

    public void OnReceiveAbort(DicomAbortSourceType source, DicomAbortReasonType reason, DicomNet net)
    {
        // Not Used
    }

    public void OnReceiveAssociateAccept(DicomAssociate association, DicomNet net)
    {
        // Not Used
    }

    public void OnReceiveAssociateReject(DicomAssociateRejectResultType result, DicomAssociateRejectSourceType source, DicomAssociateRejectReasonType reason, DicomNet net)
    {
        // Not Used
    }

    public void OnReceiveCCancelRequest(byte presentationId, ushort messageId, DicomNet net)
    {
        // Not Used
    }

    public void OnReceiveCEchoRequest(byte presentationId, ushort messageId, string affectedClass, DicomNet net)
    {
        // Not Used
    }

    public void OnReceiveCEchoResponse(byte presentationId, ushort messageId, string affectedClass, DicomCommandStatusType status, DicomNet net)
    {
        // Not Used
    }

    public void OnReceiveCFindRequest(byte presentationId, ushort messageId, string affectedClass, DicomCommandPriorityType priority, DicomDataSet dataset, DicomNet net)
    {
        // Not Used
    }

    public void OnReceiveCFindResponse(byte presentationId, ushort messageId, string affectedClass, DicomCommandStatusType status, DicomDataSet dataset, DicomNet net)
    {
        // Not Used
    }

    public void OnReceiveCGetRequest(byte presentationId, ushort messageId, string affectedClass, DicomCommandPriorityType priority, DicomDataSet dataset, DicomNet net)
    {
        // Not Used
    }

    public void OnReceiveCGetResponse(byte presentationId, ushort messageId, string affectedClass, DicomCommandStatusType status, ushort remaining, ushort completed, ushort failed, ushort warning, DicomDataSet dataset, DicomNet net)
    {
        // Not Used
    }

    public void OnReceiveCMoveRequest(byte presentationId, ushort messageId, string affectedClass, DicomCommandPriorityType priority, string MoveAE, DicomDataSet dataset, DicomNet net)
    {
        // Not Used
    }

    public void OnReceiveCMoveResponse(byte presentationId, ushort messageId, string affectedClass, DicomCommandStatusType status, ushort remaining, ushort completed, ushort failed, ushort warning, DicomDataSet dataset, DicomNet net)
    {
        // Not Used
    }

    public void OnReceiveCStoreRequest(byte presentationId, ushort messageId, string affectedClass, string Instance, DicomCommandPriorityType priority, string MoveAE, ushort moveMessageId, DicomDataSet dataset, DicomNet net)
    {
        // Not Used
    }

    public void OnReceiveCStoreResponse(byte presentationId, ushort messageId, string affectedClass, string Instance, DicomCommandStatusType status, DicomNet net)
    {
        // Not Used
    }

    public void OnReceiveData(byte presentationId, DicomDataSet commandset, DicomDataSet dataset, DicomNet net)
    {
        // Not Used
    }

    public void OnReceiveNActionRequest(byte presentationId, ushort messageId, string affectedClass, string Instance, ushort action, DicomDataSet dataset, DicomNet net)
    {
        // Not Used
    }

    public void OnReceiveNActionResponse(byte presentationId, ushort messageId, string affectedClass, string Instance, DicomCommandStatusType status, ushort action, DicomDataSet dataset, DicomNet net)
    {
        // Not Used
    }

    public void OnReceiveNCreateRequest(byte presentationId, ushort messageId, string affectedClass, string Instance, DicomDataSet dataset, DicomNet net)
    {
        // Not Used
    }

    public void OnReceiveNCreateResponse(byte presentationId, ushort messageId, string affectedClass, string Instance, DicomCommandStatusType status, DicomDataSet dataset, DicomNet net)
    {
        // Not Used
    }

    public void OnReceiveNDeleteRequest(byte presentationId, ushort messageId, string affectedClass, string Instance, DicomNet net)
    {
        // Not Used
    }

    public void OnReceiveNDeleteResponse(byte presentationId, ushort messageId, string affectedClass, string Instance, DicomCommandStatusType status, DicomNet net)
    {
        // Not Used
    }

    public void OnReceiveNGetRequest(byte presentationID, ushort messageID, string affectedClass, string instance, uint[] attributes, DicomNet net)
    {
        // Not Used
    }

    public void OnReceiveNGetResponse(byte presentationId, ushort messageId, string affectedClass, string Instance, DicomCommandStatusType status, DicomDataSet dataset, DicomNet net)
    {
        // Not Used
    }

    public void OnReceiveNReportRequest(byte presentationId, ushort messageId, string affectedClass, string Instance, ushort dicomevent, DicomDataSet dataset, DicomNet net)
    {
        // Not Used
    }

    public void OnReceiveNReportResponse(byte presentationId, ushort messageId, string affectedClass, string Instance, DicomCommandStatusType status, ushort dicomevent, DicomDataSet dataset, DicomNet net)
    {
        // Not Used
    }

    public void OnReceiveNSetRequest(byte presentationId, ushort messageId, string affectedClass, string Instance, DicomDataSet dataset, DicomNet net)
    {
        // Not Used
    }

    public void OnReceiveNSetResponse(byte presentationId, ushort messageId, string affectedClass, string Instance, DicomCommandStatusType status, DicomDataSet dataset, DicomNet net)
    {
        // Not Used
    }

    public void OnReceiveReleaseRequest(DicomNet net)
    {
        // Not Used
    }

    public void OnReceiveReleaseResponse(DicomNet net)
    {
        // Not Used
    }

    public void OnReceiveUnknown(byte presentationId, DicomDataSet commandset, DicomDataSet dataset, DicomNet net)
    {
        // Not Used
    }

    public void OnSend(DicomExceptionCode error, DicomPduType type, uint bytes, DicomNet net)
    {
        // Not Used
    }
}

class Server : IDicomEvents
{
    public DicomNet net;

    ServerConnection client;

    public Server()
    {
        net = new DicomNet(string.Empty, this);
    }

    public void OnAccept(DicomExceptionCode error, DicomNet net, object hHandle)
    {
        Debug.WriteLine("Server::OnAccept");
        client = new ServerConnection();

        Debug.WriteLine("Server Accepting Connection");
        net.Accept(client.net, hHandle);
    }


    public void OnClose(DicomExceptionCode error, DicomNet net)
    {
        // Not Used
    }

    public void OnConnect(DicomExceptionCode error, DicomNet net)
    {
        // Not Used
    }

    public void OnReceive(DicomExceptionCode error, DicomPduType type, byte[] buffer, DicomNet net)
    {
        // Not Used
    }

    public void OnReceiveAbort(DicomAbortSourceType source, DicomAbortReasonType reason, DicomNet net)
    {
        // Not Used
    }

    public void OnReceiveAssociateAccept(DicomAssociate association, DicomNet net)
    {
        // Not Used
    }

    public void OnReceiveAssociateReject(DicomAssociateRejectResultType result, DicomAssociateRejectSourceType source, DicomAssociateRejectReasonType reason, DicomNet net)
    {
        // Not Used
    }

    public void OnReceiveAssociateRequest(DicomAssociate association, DicomNet net)
    {
        // Not Used
    }

    public void OnReceiveCCancelRequest(byte presentationId, ushort messageId, DicomNet net)
    {
        // Not Used
    }

    public void OnReceiveCEchoRequest(byte presentationId, ushort messageId, string affectedClass, DicomNet net)
    {
        // Not Used
    }

    public void OnReceiveCEchoResponse(byte presentationId, ushort messageId, string affectedClass, DicomCommandStatusType status, DicomNet net)
    {
        // Not Used
    }

    public void OnReceiveCFindRequest(byte presentationId, ushort messageId, string affectedClass, DicomCommandPriorityType priority, DicomDataSet dataset, DicomNet net)
    {
        // Not Used
    }

    public void OnReceiveCFindResponse(byte presentationId, ushort messageId, string affectedClass, DicomCommandStatusType status, DicomDataSet dataset, DicomNet net)
    {
        // Not Used
    }

    public void OnReceiveCGetRequest(byte presentationId, ushort messageId, string affectedClass, DicomCommandPriorityType priority, DicomDataSet dataset, DicomNet net)
    {
        // Not Used
    }

    public void OnReceiveCGetResponse(byte presentationId, ushort messageId, string affectedClass, DicomCommandStatusType status, ushort remaining, ushort completed, ushort failed, ushort warning, DicomDataSet dataset, DicomNet net)
    {
        // Not Used
    }

    public void OnReceiveCMoveRequest(byte presentationId, ushort messageId, string affectedClass, DicomCommandPriorityType priority, string MoveAE, DicomDataSet dataset, DicomNet net)
    {
        // Not Used
    }

    public void OnReceiveCMoveResponse(byte presentationId, ushort messageId, string affectedClass, DicomCommandStatusType status, ushort remaining, ushort completed, ushort failed, ushort warning, DicomDataSet dataset, DicomNet net)
    {
        // Not Used
    }

    public void OnReceiveCStoreRequest(byte presentationId, ushort messageId, string affectedClass, string Instance, DicomCommandPriorityType priority, string MoveAE, ushort moveMessageId, DicomDataSet dataset, DicomNet net)
    {
        // Not Used
    }

    public void OnReceiveCStoreResponse(byte presentationId, ushort messageId, string affectedClass, string Instance, DicomCommandStatusType status, DicomNet net)
    {
        // Not Used
    }

    public void OnReceiveData(byte presentationId, DicomDataSet commandset, DicomDataSet dataset, DicomNet net)
    {
        // Not Used
    }

    public void OnReceiveNActionRequest(byte presentationId, ushort messageId, string affectedClass, string Instance, ushort action, DicomDataSet dataset, DicomNet net)
    {
        // Not Used
    }

    public void OnReceiveNActionResponse(byte presentationId, ushort messageId, string affectedClass, string Instance, DicomCommandStatusType status, ushort action, DicomDataSet dataset, DicomNet net)
    {
        // Not Used
    }

    public void OnReceiveNCreateRequest(byte presentationId, ushort messageId, string affectedClass, string Instance, DicomDataSet dataset, DicomNet net)
    {
        // Not Used
    }

    public void OnReceiveNCreateResponse(byte presentationId, ushort messageId, string affectedClass, string Instance, DicomCommandStatusType status, DicomDataSet dataset, DicomNet net)
    {
        // Not Used
    }

    public void OnReceiveNDeleteRequest(byte presentationId, ushort messageId, string affectedClass, string Instance, DicomNet net)
    {
        // Not Used
    }

    public void OnReceiveNDeleteResponse(byte presentationId, ushort messageId, string affectedClass, string Instance, DicomCommandStatusType status, DicomNet net)
    {
        // Not Used
    }

    public void OnReceiveNGetRequest(byte presentationID, ushort messageID, string affectedClass, string instance, uint[] attributes, DicomNet net)
    {
        // Not Used
    }

    public void OnReceiveNGetResponse(byte presentationId, ushort messageId, string affectedClass, string Instance, DicomCommandStatusType status, DicomDataSet dataset, DicomNet net)
    {
        // Not Used
    }

    public void OnReceiveNReportRequest(byte presentationId, ushort messageId, string affectedClass, string Instance, ushort dicomevent, DicomDataSet dataset, DicomNet net)
    {
        // Not Used
    }

    public void OnReceiveNReportResponse(byte presentationId, ushort messageId, string affectedClass, string Instance, DicomCommandStatusType status, ushort dicomevent, DicomDataSet dataset, DicomNet net)
    {
        // Not Used
    }

    public void OnReceiveNSetRequest(byte presentationId, ushort messageId, string affectedClass, string Instance, DicomDataSet dataset, DicomNet net)
    {
        // Not Used
    }

    public void OnReceiveNSetResponse(byte presentationId, ushort messageId, string affectedClass, string Instance, DicomCommandStatusType status, DicomDataSet dataset, DicomNet net)
    {
        // Not Used
    }

    public void OnReceiveReleaseRequest(DicomNet net)
    {
        // Not Used
    }

    public void OnReceiveReleaseResponse(DicomNet net)
    {
        // Not Used
    }

    public void OnReceiveUnknown(byte presentationId, DicomDataSet commandset, DicomDataSet dataset, DicomNet net)
    {
        // Not Used
    }

    public void OnSend(DicomExceptionCode error, DicomPduType type, uint bytes, DicomNet net)
    {
        // Not Used
    }
}

[TestMethod]
public void SendCCancleRequestSample()
{
    DicomEngine.Startup();
    DicomNet.Startup();

    Server server = new Server();
    Client client = new Client();
    //
    // Connect to server
    //

    server.net.Listen("127.0.0.1", 104, 1); // start server

    Debug.WriteLine("Client::Send Connect");
    client.net.Connect(string.Empty, 1000, "127.0.0.1", 104); // connect to server
    if (!client.Wait()) // wait for connection to finish
    {
        Debug.WriteLine("Connection timed out");
    }
    Debug.Assert(client.LastError == DicomExceptionCode.Success, "Connection failed");
    Debug.Assert(client.net.IsConnected(), "Client not connected");

    //
    // Send associate request
    //

    DicomAssociate associate = new DicomAssociate(true);

    associate.Called = "ServerTest";
    associate.Calling = "ClientTest";
    associate.ImplementClass = "1.2.840.114257.1";
    associate.ImplementationVersionName = "1";
    associate.MaxLength = 0x100000;
    associate.AddPresentationContext(1, 0, DicomUidType.VerificationClass);
    associate.AddTransfer(1, DicomUidType.ImplicitVRLittleEndian);

    Debug.WriteLine("Client::SendAssociateRequest");
    client.net.SendAssociateRequest(associate);
    if (!client.Wait()) // wait for connection to finish
    {
        Debug.WriteLine("SendAssociateRequest timed out");
    }


    Debug.WriteLine("Client::SendCCancelRequest");
    client.net.SendCCancelRequest(1, 1);
    if (!client.Wait()) // wait for SendNonSecureISCL to finish
    {
        Debug.WriteLine("SendCCancelRequest timed out");
    }
    if (client.net.IsConnected())
        client.net.CloseForced(true);

    server.net.CloseForced(true);

    DicomEngine.Shutdown();
    DicomNet.Shutdown();
}

Requirements

Target Platforms

Reference

DicomNet Class
DicomNet Members
OnReceiveCCancelRequest Method