To write code for your application that parses 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 parses and classifies 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.
• One Table class: this class is named PatientTable, since the table in the VMD file is named Patient.
• One TableRow class, named PatientTableRow and associated with the PatientTable 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 named HL7Message into which you type or copy HL7 messages to be parsed;
• A text box named ParsedOutput that will contain the parsed output;
• A button named ChangeButton that starts the parsing process.

The Sample Form

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

using System;
using System.Windows.Forms;
using iNTERFACEWARE.Chameleon;
using csharp.server.HL7;

namespace CSharpServerApplication
{
    public partial class Form1 : Form
    {
        SampleCsharpServerEngine Engine = new SampleCsharpServerEngine();
 
        public Form1()
        {
            InitializeComponent();
        }

         private void ChangeButton_Click(object sender, EventArgs e)
        {
            Engine.formInstance = this;
            Engine.ParseMessage(HL7Message.Text, null);
        }
    }

    class SampleCsharpServerEngine : HL7Engine
    {
        public Form1 formInstance = null;

        public SampleCsharpServerEngine()
        {
            base.Load("D:\\sample\\csharp_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 CRLF = "\r\n";
            try
            {
                formInstance.ParsedOutput.Text = "PatientID: " + Message.Patient(0).PatientID + CRLF
                    + "Surname: " + Message.Patient(0).Surname + CRLF
                    + "GivenName: " + Message.Patient(0).FirstName + CRLF
                    + "SSN: " + Message.Patient(0).SocialSecurityNumber + CRLF;
            }
            catch (ChameleonException ex)
            {
                ErrorEvent(ex, "Error in PatientRegister message");
            }
        }
    }
}

	Before this code can run, you must make sure that the ParsedOutput text box is set to public. This ensures that OnPatientRegisterMessage can access it.

Here, the SampleCsharpServerEngine class handles message parsing and the displaying of the parsed output. It inherits the methods of the HL7Engine class that was created by Chameleon. Three of these methods are used in this application:

• Load, which initializes the parsing engine to use the VMD file you created (this is called when the SampleCsharpServerEngine 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 message is successfully parsed.

Here is how the application works:

• The user types a message into the HL7Message field and presses the button to parse the message.
• The ChangeButton_Click method is called, which calls ParseMessage to parse the message.
• If a PatientRegister message is successfully parsed, the OnPatientRegisterMessage method is called. This method writes the message data into the ParsedOutput text box.

And here is how OnPatientRegisterMessage accesses the message data:

• The Message variable contains the parsed message data. This is an instance of the PatientRegisterMessage class.
• From Message, you can access the Patient table and its rows. A table row contains the fields defined in the table you specified in your VMD file.
• From the table row, you can access the PatientID, Surname, FirstName and SocialSecurityNumber fields.

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