DicomNetIpTypeFlags Enumeration

Summary

Specifies which Internet Protocol Version will be supported with DICOM Communication.

Syntax

C++/CLI

[FlagsAttribute()] 
public enum DicomNetIpTypeFlags

[FlagsAttribute()] 
public enum class DicomNetIpTypeFlags

Members

Value	Member	Description
0x00000000	None	None.
0x00000001	Ipv4	Only support IPv4 addresses.
0x00000002	Ipv6	Only support IPv6 addresses.
0x00000003	Ipv4OrIpv6	Support both IPv4 and IPv6 addresses.

Remarks

This enumeration is used with Listen and Connect to specify the version of the Internet Protocol that will be used.

Example

using Leadtools; 
using Leadtools.Dicom; 
 
 
/// 
[StructLayout(LayoutKind.Sequential)] 
public struct MYMSG 
{ 
   public IntPtr hwnd; 
   public uint message; 
   public IntPtr wParam; 
   public IntPtr lParam; 
   public uint time; 
   public System.Drawing.Point p; 
} 
public enum MyWaitReturn 
{ 
   Complete, 
   Timeout, 
} 
 
class MyUtils 
{ 
   [DllImport("user32.dll")] 
   [return: MarshalAs(UnmanagedType.Bool)] 
   static extern bool PeekMessage(out MYMSG lpMsg, IntPtr hWnd, 
                                  uint wMsgFilterMin, uint wMsgFilterMax, 
                                  uint wRemoveMsg); 
 
   [DllImport("user32.dll")] 
   static extern bool TranslateMessage([In] ref MYMSG lpMsg); 
   [DllImport("user32.dll")] 
   static extern IntPtr DispatchMessage([In] ref MYMSG lpmsg); 
 
   const uint PM_REMOVE = 1; 
 
   public static MyWaitReturn WaitForComplete(double mill, WaitHandle wh) 
   { 
      TimeSpan goal = new TimeSpan(DateTime.Now.AddMilliseconds(mill).Ticks); 
 
      do 
      { 
         MYMSG msg = new MYMSG(); 
 
         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 MyWaitReturn.Complete; 
         } 
 
         if (goal.CompareTo(new TimeSpan(DateTime.Now.Ticks)) < 0) 
         { 
            return MyWaitReturn.Timeout; 
         } 
 
      } while (true); 
   } 
} 
 
class MyClient : DicomNet 
{ 
   DicomExceptionCode _LastError = DicomExceptionCode.Success; 
   AutoResetEvent waitEvent = new AutoResetEvent(false); 
 
   public MyClient() 
      : base(null, DicomNetSecurityMode.None) 
   { 
   } 
 
   public DicomExceptionCode LastError 
   { 
      get 
      { 
         return _LastError; 
      } 
   } 
 
   public bool Wait() 
   { 
      _LastError = DicomExceptionCode.Success; 
      MyWaitReturn ret = MyUtils.WaitForComplete((5 * 60) * 1000, waitEvent); 
 
      return (ret == MyWaitReturn.Complete); 
   } 
 
   protected override void OnConnect(DicomExceptionCode error) 
   { 
      Debug.WriteLine("Client: Receive OnConnect"); 
      _LastError = error; 
      waitEvent.Set(); 
   } 
 
   protected override void OnReceiveReleaseResponse() 
   { 
      Debug.WriteLine("Client: Receive OnReceiveReleaseResponse"); 
      waitEvent.Set(); 
   } 
} 
 
class MyServerConnection : DicomNet 
{ 
   public bool Fail = false; 
 
   public MyServerConnection() 
      : base(null, DicomNetSecurityMode.None) 
   { 
   } 
 
   protected override void OnReceiveReleaseRequest() 
   { 
      Debug.WriteLine("Server: Receive OnReceiveReleaseRequest"); 
      SendReleaseResponse(); 
   } 
}; 
 
class MyServer : DicomNet 
{ 
   MyServerConnection client; 
 
   public MyServer() 
      : base(null, DicomNetSecurityMode.None) 
   { 
   } 
 
   public bool Fail 
   { 
      get 
      { 
         if (client == null) 
            return false; 
 
         return client.Fail; 
      } 
 
      set 
      { 
         if (client != null) 
         { 
            client.Fail = value; 
         } 
      } 
   } 
 
   protected override void OnAccept(DicomExceptionCode error) 
   { 
      Debug.WriteLine("Server: Receive OnAccept"); 
      client = new MyServerConnection(); 
 
      Accept(client); 
      string s = string.Format("\tPeerAddress: {0}\n\tPeerPort: {1}", client.PeerAddress, client.PeerPort); 
      Debug.WriteLine(s); 
   } 
} 
 
public void DicomDataSet_ListenExample() 
{ 
   DicomEngine.Startup(); 
   DicomNet.Startup(); 
 
   using (MyServer server = new MyServer()) 
   { 
      using (MyClient client = new MyClient()) 
      { 
         // The * below means to listen on all local IP addresses. 
         // The DicomNetIpTypeFlags.Ipv4OrIpv6 means to listen on both IPv4 and IPv6 addresses 
         server.Listen("*", 104, 1, DicomNetIpTypeFlags.Ipv4OrIpv6); // start server  
 
         // The client is connecting to the server using an IPv6 address. 
         // Note that "::1" is the IPv6 loopback address 
         // Alternatively, you can get type ipconfig from a command box on the local computer to get the local IPv6 address. 
         // The following is an example of a local IPv6 address: 
         //    "fe80::18bd:81f:6b02:759f" 
         client.Connect(null, 1000, "::1", 104, DicomNetIpTypeFlags.Ipv6); // connect to server  
 
         if (!client.Wait()) // wait for connection to finish  
         { 
            Assert.Fail("Connection timed out"); 
         } 
 
         if (client.LastError == DicomExceptionCode.NetAddressInUse) 
         { 
            client.CloseForced(true); 
            server.CloseForced(true); 
            DicomEngine.Shutdown(); 
            DicomNet.Shutdown(); 
         } 
 
         Assert.IsTrue(client.LastError == DicomExceptionCode.Success, $"Connection failed: {client.LastError} "); 
         Assert.IsTrue(client.IsConnected() == true, $"Client {client} not connected"); 
 
         client.SendReleaseRequest(); 
         if (!client.Wait()) // wait for connection to finish  
         { 
            Assert.Fail("Timed Out"); 
         } 
 
         // Close the connections 
         client.CloseForced(true); 
      } 
      server.CloseForced(true); 
   } 
 
   DicomEngine.Shutdown(); 
   DicomNet.Shutdown(); 
}

Requirements

Target Platforms

Reference

Leadtools.Dicom Namespace

Download our FREE evaluation

Help Version 23.0.2024.2.29

Leadtools.Dicom Assembly

Introduction

Getting Started

Namespaces

Leadtools.Dicom Namespace

Assemblies