Advanced .NET Reflection

<ms-quotation>.NET is a new generation of technology based on Web services.</ms-quotation> Is .NET able to handle the nuts-and-bolts of low-level serial communications? Let's use .NET and Reflection to implement serial communications software for controlling a large congress network.

The original Philips' software was unacceptable for the customer for various reasons. One of them was, IMHO, that although the "About" page shows "(c) 1993 - 2002", the software is still 16-bit, with the nice Windows 3.0 feeling. ;-)

I took over the software part of the project and started analyzing the requirements. Here they are in a nutshell:

• Write a serial protocol handler to communicate with the CCU using its custom protocol.
• Write a set of end-user applications to control and manage the various subsystems found in the CCU, such as microphone management, voting, delegate registration, access control, etc.

I wanted to do the software in .NET (you've probably guessed that:-), but .NET doesn't have native support for serial communications. So I've searched the Internet and found a nice piece of code provided by John Hind (see links). It worked great right from the start and I haven't had any problem with it till now. Great work, thanks John!

The "funny" part of this project turned out to be the protocol handler, mainly because the protocol specifications were a bit incomplete and imprecise (and I'm very tolerant with this wording;-).

The protocol basically describes how to transfer messages between the CCU and the controlling PC. The message data are opaque streams of bytes. The actual structure of the data is implied by the message type, which is defined in the documentation using C-style syntax. For illustration, here is the definition of a message that the CCU sends when a delegate inserts a PIN card into her delegate unit (don't worry about the semantics, its not important for this discussion):

typedef struct
{
	WORD		wUnitId;
	WORD		wDelegateId;
	BYTE		byAttend;
} AT_T_DEL_ATTEND;

• Easily define the structures as VB.NET classes.
• Automatically handle the conversion of the classes to and from byte streams transmitted over the serial line.

I've worried a bit about performance because Reflection is notoriously mentioned as slow. But hey, MS used it within their own remoting infrastructure, so it won't be that bad, I thought.

I came up with the following design:

The CcuSerializable attribute can be applied to a class or a field to control the serialization process.

The SerializationManager class that implements the actual serialization and deserialization of CcuSerializable objects to and from byte streams. SerializationManager uses Reflection extensively to interrogate a set of CcuSerializable fields for a given class, as well as to actually write and read the fields' values to and from byte streams, for example:

Private Sub SerializeInteger( _
  ByVal obj As Object, _
  ByVal field As FieldInfo, _
  ByVal attr As CcuSerializableAttribute, _
  ByVal writer As System.IO.BinaryWriter)
	
	Dim Value As Integer = CInt(field.GetValue(obj))
	writer.Write(Value)
End Sub

Private Sub DeserializeInteger( _
	ByVal obj As Object, _
	ByVal field As FieldInfo, _
	ByVal attr As CcuSerializableAttribute, _
	ByVal reader As System.IO.BinaryReader)
	
	Dim Value As Integer = reader.ReadInt32()
	field.SetValue(obj, Value)
End Sub

With SerializationManager, implementing the various control applications was easy. I've had just to tag the serializable classes with the CcuSerializable attribute like this...

<CcuSerializable()> _
Public Class AttnEntry
	<CcuSerializable()> Private _UnitID As Short
	<CcuSerializable()> Private _DelegateID As Short
	<CcuSerializable()> Private _Status As Byte
	...

That's it.

Well, the project isn't completed yet. It will enter beta testing at the beginning of August (this year;-). The software will control over 150 delegate units and I've tested with just 15 so far. Nevertheless, I'm quite confident that the software will survive the load of the production environment and that the use of Reflection won't be a problem. Stay tuned, I'm going to write another article after the project completes.

(And please, don't worry--I'll be honest and tell you when something would go wrong. After all, VBInfoZine is about real projects and they have a tendency to fail sometimes:-)

© Palo Mraz - Monday, July 14, 2003

Links

http://www.philipscsi.com/ - The makers of the DCN product line. Formerly Philips Communication, Security & Imaging, now owned by Bosch.

http://www.vbinfozine.com/downloads/sm.txt - The SerializationManager class' source code.