Sending An HL7 Message, Receiving It Using A Listener And Sending An Acknowledgement Back

MSH|^~\&|SENDING_APPLICATION|SENDING_FACILITY|RECEIVING_APPLICATION|RECEIVING_FACILITY|80440613081417||ADT^A04|294576460110672083618|P|2.3||||
EVN|A04|20110613083617|||
PID|1||135769||WATSON^JAMES^||19281118|M|||123 Main St.^^RIVER SAN MARINA^FL^32830||(506)523-6289^^^[email protected]|||||1719|55331188||||||||||||||||||||
PV1|1|O|||||7^John^Carter^^MD^^^^|||||||||||||||||||||||||||||||||||||||||||||

private Dictionary<int, String> fields; 

public Segment() {  
    fields = new Dictionary < int, string > (100);  
}

/// <summary>  
/// First field of a segment is the name of the segment  
/// </summary>  
public string Name {  
    get {  
        if (!fields.ContainsKey(0)) {  
            return String.Empty;  
        }  
        return fields[0];  
    }  
}

We can also add a method to add fields to the segment and a method to retrieve fields by key (index of the field). Then, we may need a method to split the fields of a segment and add them to the fields dictionary.

Note

Since you can download the code which is available with this article, I am not giving the full method definition here.

private string Field(int key) {  
    -- -- -- -- -- --  
    -- -- -- -- -- --  
}  
public void Field(int key, string value) {  
    -- -- -- -- -- --  
    -- -- -- -- -- --  
} 

Now, we may need a method to split the fields into a segment and add them to the fields dictionary.

Here is the method signature:

public void DeSerializeSegment(string segment) {  
    -- -- -- -- -- --  
    -- -- -- -- -- --  
}

Finally, we need a method to create an HL7 message string out of the segments dictionary for sending the acknowledgment message.

I named the method - SerializeSegment() :

string SerializeSegment()  
{  
    -- -- -- -- -- --  
    -- -- -- -- -- --  
}

Our Segment class is se, now let us go back to the Message class and finish it off.

We need a constant variable to check if the field is the MSH header.

private const string MSH = "MSH";

We now need a list to store the segments of the message and the definition goes here:

private LinkedList<Segment> _segments;  

That’s it for the fields of the class.

I am going to add methods to various Message operations.

For adding a segment to the list:

public void Add(Segment segment) {  
    -- -- -- -- -- --  
    -- -- -- -- -- --  
}

For adding the segments to the message object:

public void DeSerializeMessage(string msg)  
{  
    -- -- -- -- -- --  
    -- -- -- -- -- --  
} 

For serializing the message object to a string:

public string SerializeMessage()  
{  
    -- -- -- -- -- --  
    -- -- -- -- -- --  
}

With that, we are ready with our message object.

Step 5. Add logic to send message

For a listener to receive some message, there should be a sender to which the listener to subscribe. So, go to the Program.cs class and add some logic to do some.

We can listen to any available server and port. I am here using the localhost and port 7777.

private static readonly byte[] Localhost = { 127, 0, 0, 1 };  
private const int Port = 7777; 

Let us create a separate thread to implement the sender so that both the sender and listener work parallelly.

First, create an IP address object and an IPEndPoint object using classes from the System.Net namespace.

System.Net.IPAddress address = new IPAddress(Localhost);  
System.Net.IPEndPoint endPoint = new IPEndPoint(address, Port); 

I am going to use the power of threading for the listener to work independently, I mean without blocking.

ystem.Threading.Thread listnerThread = new Thread(new ThreadStart(Listen));  

We can create another thread to implement the message sending logic.

Thread senderThread = new Thread(new ThreadStart(Send));  

You just need to start the threads and this is all that we need to do in the Program.cs

So, what goes inside Listen and Send methods? Before explaining that, we can move the logic of message listening and message sending to two new classes.

Step 6. Create Subscriber class

Create a new class and name it Subscriber. This is our class which handles the message listening part.

We already discussed that the listener is just a TCP listener. So, let us create a listener using by creating a new Socket object.

System.Net.Sockets.Socket listener = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

Then you need to bind the listener to the endpoint of our interest and start listening.

listener.Bind(endPoint);  
listener.Listen(3);  

Once you have received the message, you can handle it in the way you wish. Then you should acknowledge the sender that you have received the message.

The message you get will be packaged in an MLLP frame in the format <VT> data <FS><CR>. You need to remove these special characters before processing them.

• VT – Vertical Tab
• FS – File Separator
• CR – Carriage Return

Acknowledgment message has a format and you should follow it. It is an MSH segment with acknowledged time, version info etc. Finally, the message should be wrapped inside an MLLP frame.

Since we have moved the listener logic to a class, the thread declaration will change like below:

listnerThread = new Thread(new ThreadStart(subscriber.Listen));  

Step 7. Create a Publisher class

Create a new class and name it Publisher. This is our class which handles the message sending part.

The sender will be sending the message to a port. The applications which are subscribed to the server will be listening to this port.

So where is the HL7 message?

I have attached a sample HL7 message file (SampleHL7.hl7) to the project.

What I am going to do is just reading the message from the file and sending it across the TCP socket so that whichever applications are listening to the same address and port will be able to capture the data.

As I have mentioned earlier, the HL7 is transmitted over TCP/IP in MLLP frames to identify the start and end of a message.

So before, sending the message, we need to wrap it like this: <VT> data <FS><CR>

I will once again create a socket for sending.

Socket sender = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);  

Next thing, read the data from the file as an array of bytes.

Add VT character (hexadecimal value 0x0b) at the beginning and FS (hexadecimal value 0x1c) and CR (hexadecimal value 0x0d) at the end of the bytes.

sender.Connect(endPoint);  

establishes a connection to the port in the host address.

sender.Send(dataToSend);

will send the data (Hl7 message) as a stream of bytes.

Since we have moved the message sending logic to a class, the thread declaration will change like below:

senderThread = new Thread(new ThreadStart(publisher.Send));  

Congratulations, we have managed to send and receive an HL7 message.

And here is your output: