Step 5 - Writing C# Code to Process Messages

Looking for Iguana v.5 or v.6? Learn More or see the Help Center.

Step 5 - Writing C# Code to Process Messages

To write code for your application that parses and then generates HL7 messages, you first need to know what classes are created when you use your Chameleon VMD file to generate C# stubcode for your application.

The Engine class represents the Chameleon engine that classifies and generates the HL7 messages.
The Message class represents a message definition you specified in the VMD file. One Message class is created for each message definition in the file. These classes are accessible from the Engine class.
The Table class represents a table you created when building the VMD file. This class enables you to access any row of the table. One Table class is created for each table you define.
The TableRow class represents a row of its table. TableRow objects are accessed from the Table class. One TableRow class is created for each table you define.

In this example, the following classes have been created:

The Engine class: in the example, this class is named HL7Engine, since you specified HL7 as the last part of the prefix when generating your stubcode.
One Message class: this class is named PatientRegisterMessage, since the message definition in the VMD file is named PatientRegister.
Three Table classes: these classes are named PatientTable, MessageInfoTable and NextOfKinTable, since the tables in the VMD file are named Patient, MessageInfo and NextOfKin.
A TableRow class named PatientTableRow and associated with the PatientTable class.
A TableRow class named MessageInfoTableRow and associated with the MessageInfoTable class.
A TableRow class named NextOfKinTableRow and associated with the NextOfKinTable class.

Now that you have this information, you are ready to write the C# code for the sample application. Recall that the sample application contains:

A text box for the input HL7 message, named HL7InputField;
Text boxes for the first next of kin, named Surname1Field, FirstName1Field and Relationship1Field;
Text boxes for the second next of kin, named Surname2Field, FirstName2Field and Relationship2Field;
A button named GenerateMessageButton that starts the generation process;
A text box named HL7OutputField that will contain the generated HL7 message.

The Sample Form

The following C# code example implements HL7 message processing in this sample application:

using System;
using System.Text;
using System.Windows.Forms;
using iNTERFACEWARE.Chameleon;
using csharp.clientserver.HL7;

namespace CSharpClientServerApplication
{
    public partial class Form1 : Form
    {
        SampleCsharpClientServerEngine Engine = new SampleCsharpClientServerEngine();

        public Form1()
        {
            InitializeComponent();
        }

        private void GenerateMessageButton_Click(object sender, EventArgs e)
        {
            StringBuilder ParseString = new StringBuilder();

            Engine.formInstance = this;
            ParseString.Append(HL7InputField.Text);
            ParseString.Replace("\n", "");
            ParseString.Append("\rNK1||\r");
            Engine.ParseMessage(ParseString.ToString(), null);
        }
    }


    class SampleCsharpClientServerEngine : HL7Engine
    {
        public Form1 formInstance = null;

        public SampleCsharpClientServerEngine()
        {
            base.Load("D:\\sample\\csharp_client_server.vmd");
        }

        public override void ParseMessage(string flatWire, Transport aTransport)
        {
            try
            {
                base.ParseMessage(flatWire, aTransport);
            }
            catch (ChameleonException ex)
            {
                ErrorEvent(ex, "Error parsing message");
            }
            catch (Exception ex)
            {
                ErrorEvent(ex, "General exception");
            }
        }
        public override void OnPatientRegisterMessage(PatientRegisterMessage Message, Transport aTransport)
        {
            string GeneratedMessage;
            StringBuilder GeneratedOutput = new StringBuilder();

            if (formInstance.Surname1Field.Text != "")
            {
                Message.NextOfKin(0).Surname = formInstance.Surname1Field.Text;
                Message.NextOfKin(0).FirstName = formInstance.FirstName1Field.Text;
                Message.NextOfKin(0).Relationship = formInstance.Relationship1Field.Text;
                Message.NextOfKin(0).IDNumber = "1";
            }
            if (formInstance.Surname2Field.Text != "")
            {
                if (formInstance.Surname1Field.Text != "")
                {
                    Message.NextOfKin().AddRow();
                    Message.NextOfKin(1).Surname = formInstance.Surname2Field.Text;
                    Message.NextOfKin(1).FirstName = formInstance.FirstName2Field.Text;
                    Message.NextOfKin(1).Relationship = formInstance.Relationship2Field.Text;
                    Message.NextOfKin(1).IDNumber = "2";
                }
                else
                {
                    Message.NextOfKin(0).Surname = formInstance.Surname2Field.Text;
                    Message.NextOfKin(0).FirstName = formInstance.FirstName2Field.Text;
                    Message.NextOfKin(0).Relationship = formInstance.Relationship2Field.Text;
                    Message.NextOfKin(0).IDNumber = "1";
                }
            }
            Message.Patient(0).PatientID = "PID" + Message.Patient(0).PatientID;
            GeneratedMessage = Message.GenerateMessage();
            GeneratedOutput.Append(GeneratedMessage);
            GeneratedOutput.Replace("\r", "\r\n");
            formInstance.HL7OutputField.Text = GeneratedOutput.ToString();
        }
    }
}

Here, the SampleCsharpClientServerEngine class inherits the methods of the HL7Engine class that was created by Chameleon. This application uses the following methods defined for this class:

Load, which initializes the processing engine to use the VMD file you created (this is called when the SampleCsharpClientServerEngine object is created);
ParseMessage, which parses an HL7 message based on the information in the VMD file;
OnPatientRegisterMessage, which is the method that is called when a PatientRegister method is successfully parsed.

To generate the message, the application uses GenerateMessage, which is a method defined for the PatientRegisterMessage class that generates an HL7 message based on the information in the VMD file. This method is called from within OnPatientRegisterMessage, which means that an output message is generated every time an input message is parsed.

Here is how the application works:

The user types a message into the HL7InputField text box, types next of kin information into the other input text boxes, and presses the Generate Message button.
This calls GenerateMessageButton_Click, which loads the message from the HL7InputField text box and appends an empty NK1 segment to it. (The VMD file needs this empty NK1 segment to work properly.) The method then calls ParseMessage, which parses the input message.
If a PatientRegister message is successfully parsed, OnPatientRegisterMessage is called. This method loads the information from the next of kin text boxes into the data tables defined for the next of kin segment.
This method also updates the PatientID field in the PID segment, changing it from a numeric value to PID followed by the numeric value.
The method then calls GenerateMessage to generate the updated message.
The generated message is displayed in the HL7OutputField text box.


	When the user types or copies an HL7 message into the HL7InputField text box, each segment of the message is terminated by a carriage return character and a line feed character. Since the HL7 definition specifies that each segment of an HL7 message must be terminated by a carriage return only, the GenerateMessageButton_Click method must strip the line feed characters from the message before it can be parsed.

The HL7 message displayed in the output text box needs to be modified slightly before it can be displayed.

When the HL7 message is generated, each segment of the message is terminated by a carriage return only. To display the message, each carriage return is replaced by a carriage return and line feed combination.

If you are sending the generated message to another application, do not replace the carriage return with a carriage return and line feed. (In this example, the variable GeneratedMessage contains an unmodified version of the message.)

Here is how the next of kin data tables are loaded with the information that is used to generate the message:

The Message variable contains the data for the message being generated. This is an instance of the PatientRegisterMessage class.
From Message, you can access the NextOfKin table and its rows. A table row contains the fields defined in the table you specified in your VMD file.
From the NextOfKin table row, you can access the Surname, FirstName and Relationship fields. The values from the input text boxes are assigned to these fields. A constant value is assigned to the IDNumber field, indicating whether this is the first or second next of kin defined.
From the Patient table row, you can access and update the PatientID field or any other field in the Patient table. Similarly, you can use the MessageInfo table row to access and update the values in the MessageInfo table.

Now that you have written your application code, the final step is to test the application.

Products Manual

iNTERFACEWARE

Step 5 - Writing C# Code to Process Messages