SendNGetRequest Method (DicomNet)

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

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 * 60) * 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 OnReceiveReleaseResponse(DicomNet net)
    {
        Debug.WriteLine("Client::OnReceiveReleaseResponse");
        waitEvent.Set();
    }

    public void OnReceiveNGetResponse(byte presentationID, ushort messageID, string affectedClass, string instance, DicomCommandStatusType status, DicomDataSet dataSet, DicomNet net)
    {
        Debug.WriteLine("Client::OnReceiveNGetResponse");
        DicomElement element;

        Debug.Assert(messageID == 1, "Invalid message id.  Should be 1");
        Debug.Assert(affectedClass == DicomUidType.SCImageStorage, "Affected class should be PatientRootQueryMove: " + DicomUidType.PatientRootQueryMove);
        Debug.Assert(status == DicomCommandStatusType.Success, "Status should be success");
        Debug.Assert(dataSet != null, "Dataset should not be null");

        //
        // Check Dataset
        //

        element = dataSet.FindFirstElement(null, DicomTagConstants.PatientName, true);
        Debug.Assert(element != null, "Element (PatientName) should not be null");
        Debug.Assert(dataSet.GetStringValue(element, 0) == "TEST", "PatientName should be TEST");

        element = dataSet.FindFirstElement(null, DicomTagConstants.PatientID, true);
        Debug.Assert(element != null, "Element (PatientID) should not be null");
        Debug.Assert(dataSet.GetStringValue(element, 0) == "ID", "PatientID should be ID");

        element = dataSet.FindFirstElement(null, DicomTagConstants.PatientSex, true);
        Debug.Assert(element != null, "Element (PatientSex) should not be null");
        Debug.Assert(dataSet.GetStringValue(element, 0) == "M", "PatientSex should be M");

        element = dataSet.FindFirstElement(null, DicomTagConstants.NumberOfPatientRelatedInstances, true);
        Debug.Assert(element != null, "Element (NumberOfPatientRelatedInstances) should not be null");
        Debug.Assert(dataSet.GetConvertValue(element) == "1", "NumberOfPatientRelatedInstances should be 1");

        waitEvent.Set();
    }

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

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

    public void OnReceive(DicomExceptionCode error, DicomPduType pduType, 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 cs, DicomDataSet ds, 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 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 OnReceiveUnknown(byte presentationID, DicomDataSet commandset, DicomDataSet dataSet, DicomNet net)
    {
        // Not Used
    }

    public void OnSend(DicomExceptionCode error, DicomPduType pduType, 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 OnReceiveReleaseRequest(DicomNet net)
    {
        Debug.WriteLine("ServerConnection::OnReceiveReleaseRequest");
        Debug.WriteLine("ServerConnection::SendReleaseResponse");
        net.SendReleaseResponse();
    }

    public void OnReceiveNGetRequest(byte presentationID, ushort messageID, string affectedClass, string instance, uint[] attributes, DicomNet net)
    {
        Debug.WriteLine("ServerConnection::OnReceiveNGetRequest");
        DicomDataSet ds = new DicomDataSet();
        DicomElement element;

        byte id = net.Association.FindAbstract(affectedClass);

        Debug.Assert(id == presentationID, "PresentationID is invalid");
        Debug.Assert(messageID == 1, "Invalid message id.  Should be 1");
        Debug.Assert(instance == "1.1.1.1.9999.2", "Instance should be 1.1.1.1.9999.2");
        Debug.Assert(attributes.Length == 4, "There should be 4 attributes");

        Debug.Assert(attributes[0] == DicomTagConstants.PatientName, "Attribute 0 should be PatientName");
        Debug.Assert(attributes[1] == DicomTagConstants.PatientID, "Attribute 1 should be PatientID");
        Debug.Assert(attributes[2] == DicomTagConstants.PatientSex, "Attribute 2 should be PatientSex");
        Debug.Assert(attributes[3] == DicomTagConstants.NumberOfPatientRelatedInstances, "Attribute 3 should be NumberOfPatientRelatedInstances");

        ds.Initialize(DicomClassType.Undefined, DicomDataSetInitializeType.ImplicitVRLittleEndian);

        element = ds.FindFirstElement(null, DicomTagConstants.PatientName, true);
        if (element == null)
        {
           element = ds.InsertElement(null, false, DicomTagConstants.PatientName, DicomVRType.UN, false, 0);
        }
        ds.SetStringValue(element, "TEST", DicomCharacterSetType.Default);

        element = ds.FindFirstElement(null, DicomTagConstants.PatientID, true);
        if (element == null)
        {
           element = ds.InsertElement(null, false, DicomTagConstants.PatientID, DicomVRType.UN, false, 0);
        }
        ds.SetStringValue(element, "ID", DicomCharacterSetType.Default);

        element = ds.FindFirstElement(null, DicomTagConstants.PatientSex, true);
        if (element == null)
        {
           element = ds.InsertElement(null, false, DicomTagConstants.PatientSex, DicomVRType.UN, false, 0);
        }
        ds.SetStringValue(element, "M", DicomCharacterSetType.Default);

        element = ds.FindFirstElement(null, DicomTagConstants.NumberOfPatientRelatedInstances, true);
        if (element == null)
        {
           element = ds.InsertElement(null, false, DicomTagConstants.NumberOfPatientRelatedInstances, DicomVRType.UN, false, 0);
        }
        ds.SetConvertValue(element, "1", 1);

        Debug.WriteLine("ServerConnection::SendNGetResponse");
        net.SendNGetResponse(presentationID, messageID, affectedClass, instance, DicomCommandStatusType.Success, ds);
    }

    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 pduType, 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 cs, DicomDataSet ds, 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 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 OnReceiveReleaseResponse(DicomNet net)
    {
        // Not Used
    }

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

    public void OnSend(DicomExceptionCode error, DicomPduType pduType, 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)
    {
        throw new NotImplementedException();
    }

    public void OnConnect(DicomExceptionCode error, DicomNet net)
    {
        throw new NotImplementedException();
    }

    public void OnReceive(DicomExceptionCode error, DicomPduType pduType, byte[] buffer, DicomNet net)
    {
        throw new NotImplementedException();
    }

    public void OnReceiveAbort(DicomAbortSourceType source, DicomAbortReasonType reason, DicomNet net)
    {
        throw new NotImplementedException();
    }

    public void OnReceiveAssociateAccept(DicomAssociate association, DicomNet net)
    {
        throw new NotImplementedException();
    }

    public void OnReceiveAssociateReject(DicomAssociateRejectResultType result, DicomAssociateRejectSourceType source, DicomAssociateRejectReasonType reason, DicomNet net)
    {
        throw new NotImplementedException();
    }

    public void OnReceiveAssociateRequest(DicomAssociate association, DicomNet net)
    {
        throw new NotImplementedException();
    }

    public void OnReceiveCCancelRequest(byte presentationID, ushort messageID, DicomNet net)
    {
        throw new NotImplementedException();
    }

    public void OnReceiveCEchoRequest(byte presentationID, ushort messageID, string affectedClass, DicomNet net)
    {
        throw new NotImplementedException();
    }

    public void OnReceiveCEchoResponse(byte presentationID, ushort messageID, string affectedClass, DicomCommandStatusType status, DicomNet net)
    {
        throw new NotImplementedException();
    }

    public void OnReceiveCFindRequest(byte presentationID, ushort messageID, string affectedClass, DicomCommandPriorityType priority, DicomDataSet dataSet, DicomNet net)
    {
        throw new NotImplementedException();
    }

    public void OnReceiveCFindResponse(byte presentationID, ushort messageID, string affectedClass, DicomCommandStatusType status, DicomDataSet dataSet, DicomNet net)
    {
        throw new NotImplementedException();
    }

    public void OnReceiveCGetRequest(byte presentationID, ushort messageID, string affectedClass, DicomCommandPriorityType priority, DicomDataSet dataSet, DicomNet net)
    {
        throw new NotImplementedException();
    }

    public void OnReceiveCGetResponse(byte presentationID, ushort messageID, string affectedClass, DicomCommandStatusType status, ushort remaining, ushort completed, ushort failed, ushort warning, DicomDataSet dataSet, DicomNet net)
    {
        throw new NotImplementedException();
    }

    public void OnReceiveCMoveRequest(byte presentationID, ushort messageID, string affectedClass, DicomCommandPriorityType priority, string moveAE, DicomDataSet dataSet, DicomNet net)
    {
        throw new NotImplementedException();
    }

    public void OnReceiveCMoveResponse(byte presentationID, ushort messageID, string affectedClass, DicomCommandStatusType status, ushort remaining, ushort completed, ushort failed, ushort warning, DicomDataSet dataSet, DicomNet net)
    {
        throw new NotImplementedException();
    }

    public void OnReceiveCStoreRequest(byte presentationID, ushort messageID, string affectedClass, string instance, DicomCommandPriorityType priority, string moveAE, ushort moveMessageID, DicomDataSet dataSet, DicomNet net)
    {
        throw new NotImplementedException();
    }

    public void OnReceiveCStoreResponse(byte presentationID, ushort messageID, string affectedClass, string instance, DicomCommandStatusType status, DicomNet net)
    {
        throw new NotImplementedException();
    }

    public void OnReceiveData(byte presentationID, DicomDataSet cs, DicomDataSet ds, DicomNet net)
    {
        throw new NotImplementedException();
    }

    public void OnReceiveNActionRequest(byte presentationID, ushort messageID, string affectedClass, string instance, ushort action, DicomDataSet dataSet, DicomNet net)
    {
        throw new NotImplementedException();
    }

    public void OnReceiveNActionResponse(byte presentationID, ushort messageID, string affectedClass, string instance, DicomCommandStatusType status, ushort action, DicomDataSet dataSet, DicomNet net)
    {
        throw new NotImplementedException();
    }

    public void OnReceiveNCreateRequest(byte presentationID, ushort messageID, string affectedClass, string instance, DicomDataSet dataSet, DicomNet net)
    {
        throw new NotImplementedException();
    }

    public void OnReceiveNCreateResponse(byte presentationID, ushort messageID, string affectedClass, string instance, DicomCommandStatusType status, DicomDataSet dataSet, DicomNet net)
    {
        throw new NotImplementedException();
    }

    public void OnReceiveNDeleteRequest(byte presentationID, ushort messageID, string affectedClass, string instance, DicomNet net)
    {
        throw new NotImplementedException();
    }

    public void OnReceiveNDeleteResponse(byte presentationID, ushort messageID, string affectedClass, string instance, DicomCommandStatusType status, DicomNet net)
    {
        throw new NotImplementedException();
    }

    public void OnReceiveNGetRequest(byte presentationID, ushort messageID, string affectedClass, string instance, uint[] attributes, DicomNet net)
    {
        throw new NotImplementedException();
    }

    public void OnReceiveNGetResponse(byte presentationID, ushort messageID, string affectedClass, string instance, DicomCommandStatusType status, DicomDataSet dataSet, DicomNet net)
    {
        throw new NotImplementedException();
    }

    public void OnReceiveNReportRequest(byte presentationID, ushort messageID, string affectedClass, string instance, ushort dicomevent, DicomDataSet dataSet, DicomNet net)
    {
        throw new NotImplementedException();
    }

    public void OnReceiveNReportResponse(byte presentationID, ushort messageID, string affectedClass, string instance, DicomCommandStatusType status, ushort dicomevent, DicomDataSet dataSet, DicomNet net)
    {
        throw new NotImplementedException();
    }

    public void OnReceiveNSetRequest(byte presentationID, ushort messageID, string affectedClass, string instance, DicomDataSet dataSet, DicomNet net)
    {
        throw new NotImplementedException();
    }

    public void OnReceiveNSetResponse(byte presentationID, ushort messageID, string affectedClass, string instance, DicomCommandStatusType status, DicomDataSet dataSet, DicomNet net)
    {
        throw new NotImplementedException();
    }

    public void OnReceiveReleaseRequest(DicomNet net)
    {
        throw new NotImplementedException();
    }

    public void OnReceiveReleaseResponse(DicomNet net)
    {
        throw new NotImplementedException();
    }

    public void OnReceiveUnknown(byte presentationID, DicomDataSet commandset, DicomDataSet dataSet, DicomNet net)
    {
        throw new NotImplementedException();
    }

    public void OnSend(DicomExceptionCode error, DicomPduType pduType, uint bytes, DicomNet net)
    {
        throw new NotImplementedException();
    }
}

        
public void SendNGetRequestSample()
{
    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);
    long[] attributes = new long[4];

    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);
    associate.AddPresentationContext(3, 0, DicomUidType.SCImageStorage);
    associate.AddTransfer(3, DicomUidType.ImplicitVRLittleEndian);

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

    byte pid = client.net.Association.FindAbstract(DicomUidType.SCImageStorage);

    // Set NGet attributes
    attributes[0] = DicomTagConstants.PatientName;
    attributes[1] = DicomTagConstants.PatientID;
    attributes[2] = DicomTagConstants.PatientSex;
    attributes[3] = DicomTagConstants.NumberOfPatientRelatedInstances;

    Debug.WriteLine("Client::SendNGetRequest");
    client.net.SendNGetRequest(pid, 1, DicomUidType.SCImageStorage, "1.1.1.1.9999.2", attributes, attributes.Length);
    if (!client.Wait()) // wait for NGet to finish
    {
        Debug.WriteLine("SendNGetRequest timed out");
    }
    client.net.CloseForced(true);
    server.net.CloseForced(true);


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