protected virtual void OnSend(
DicomExceptionCode error,
DicomPduType type,
int length
)
protected:
virtual void OnSend(
DicomExceptionCode error,
DicomPduType type,
int length
)
error
An error code.
type
The type of data that was sent.
length
The number of bytes of the data actually sent.
When one of the DicomNet.SendXXX methods is called, the message is not sent immediately. It is placed in a network queue and sent later. When the data is actually sent, this method is called to let the calling AE know that the data has been sent. To customize this method, you must derive a class from DicomNet and override this method.
This is a comprehensive sample that shows how to process a DICOM C-Store operation on both the SCP (server) and the SCU (client) sides.
using Leadtools.Dicom;
using Leadtools.Dicom.Common.DataTypes.Status;
using Leadtools.Dicom.Common.Extensions;
[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, DicomNetSecurityMode.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 OnReceiveCStoreResponse(byte presentationID, int messageID, string affectedClass, string instance, DicomCommandStatusType status)
{
Debug.Assert(status == DicomCommandStatusType.Success, "Status should be success");
DicomDataSet cs = this.GetCommandSet();
string statusAllString = string.Empty;
if (cs != null)
{
StatusAll statusAll = cs.Get<StatusAll>();
if (statusAll != null)
{
StatusFormatFlags flags = StatusFormatFlags.None;
statusAllString = statusAll.ToString(flags, "\n\t", "\t");
// Print the friendly-string showing status-related elements
Debug.WriteLine(statusAllString);
}
}
waitEvent.Set();
}
protected override void OnReceive(DicomExceptionCode error, DicomPduType pduType, IntPtr buffer, int bytes)
{
base.OnReceive(error, pduType, buffer, bytes);
}
protected override void OnSend(DicomExceptionCode error, DicomPduType type, int length)
{
base.OnSend(error, type, length);
}
}
class ServerConnection : DicomNet
{
public ServerConnection()
: base(null, DicomNetSecurityMode.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 OnReceiveCStoreRequest(byte presentationID, int messageID, string affectedClass, string instance, DicomCommandPriorityType priority, string moveAE, int moveMessageID, DicomDataSet dataSet)
{
byte id = Association.FindAbstract(affectedClass);
Debug.Assert(id == presentationID, "PresentationID is invalid");
Debug.Assert(messageID == 2, "Invalid message id. Should be 2");
Debug.Assert(dataSet != null, "Dataset should not be null");
Debug.Assert(moveAE == "NONE", "Move AE should be NONE");
Debug.Assert(moveMessageID == 1, "Move message id should be 1");
Debug.Assert(priority == DicomCommandPriorityType.Medium, "Priority should be medium");
SendCStoreResponse(presentationID, messageID, affectedClass, instance, DicomCommandStatusType.Success);
}
}
class Server : DicomNet
{
ServerConnection client;
public Server()
: base(null, DicomNetSecurityMode.None)
{
}
protected override void OnAccept(DicomExceptionCode error)
{
client = new ServerConnection();
Accept(client);
}
}
public void SendCStoreRequestSample()
{
DicomEngine.Startup();
DicomNet.Startup();
using (Server server = new Server())
{
using (Client client = new Client())
{
string storageClass = "";
string storageInstance = "998.998.1.1.19950214.94000.1.102";
DicomDataSet ds = new DicomDataSet();
DicomElement element;
string transferSyntax = DicomUidType.JPEGLosslessNonhier14;
string dicomFileName = Path.Combine(LEAD_VARS.ImagesDir, "DICOM","image3.dcm");
//
// 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");
ds.Load(dicomFileName, DicomDataSetLoadFlags.LoadAndClose);
element = ds.FindFirstElement(null, DicomTag.MediaStorageSOPClassUID, true);
if (element != null)
{
storageClass = ds.GetStringValue(element, 0);
}
if (storageClass.Length == 0)
{
element = ds.FindFirstElement(null, DicomTag.SOPInstanceUID, true);
if (element != null)
{
storageClass = ds.GetStringValue(element, 0);
}
}
if (storageClass.Length == 0)
storageClass = "1.1.1.1";
//
// Get Image transfer syntax
//
element = ds.FindFirstElement(null, DicomTag.TransferSyntaxUID, true);
if (element != null)
{
transferSyntax = ds.GetStringValue(element, 0);
}
element = ds.FindFirstElement(null, DicomTag.SOPInstanceUID, true);
if (element != null)
{
storageInstance = ds.GetStringValue(element, 0);
}
//
// 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);
associate.AddPresentationContext(3, 0, storageClass);
associate.AddTransfer(3, transferSyntax);
client.SendAssociateRequest(associate);
if (!client.Wait()) // wait for connection to finish
{
Debug.Fail("SendAssociateRequest timed out");
}
//
// Send Echo Request
//
byte pid = client.Association.FindAbstract(storageClass);
client.SendCStoreRequest(pid, 2, storageClass, storageInstance,
DicomCommandPriorityType.Medium, "NONE", 1, ds);
if (!client.Wait()) // wait for connection to finish
{
Debug.Fail("SendCStoreRequest timed out");
}
client.CloseForced(true);
}
server.CloseForced(true);
}
DicomEngine.Shutdown();
DicomNet.Shutdown();
}
static class LEAD_VARS
{
public const string ImagesDir = @"C:\LEADTOOLS23\Resources\Images";
}
Help Collections
Raster .NET | C API | C++ Class Library | HTML5 JavaScript
Document .NET | C API | C++ Class Library | HTML5 JavaScript
Medical .NET | C API | C++ Class Library | HTML5 JavaScript
Medical Web Viewer .NET
Multimedia
Direct Show .NET | C API | Filters
Media Foundation .NET | C API | Transforms
Supported Platforms
.NET, Java, Android, and iOS/macOS Assemblies
Imaging, Medical, and Document
C API/C++ Class Libraries
Imaging, Medical, and Document
HTML5 JavaScript Libraries
Imaging, Medical, and Document