进程间通信包创建

Question

I'm writing an inter-process communication protocol where ac# client is calling APIs in a server process that will be written in different languages (Java, C, C++, etc.) Both processes run on the same machine and the communication layer itself is not the issue (Currently I'm using sockets since it's supported by most languages but may use shared memory later) There're about 180 APIs in total, each of course with its own set of parameters of various types. Since the server can be written in any language, I'm converting all parameters to an array of bytes, put it in a packet with the API identifier and sending it over to the other process where it will be decoded based on the API identifier. The return data from the server process will be formatted the same way.

What I'm looking for is the fastest way (and preferably a single function) that takes variable number of different-type parameters and convert them into a byte array. Currently, I'm using BitConverter class to convert each parameter to an array of bytes and concatenate all arrays into one. There are no reference-type parameters except strings, which will be converted to an array of bytes with the first 2-bytes containing string length. I have control over both the client and server so each knows what order of parameters to expect in the packet (Based on API ID) and the size of each parameter.

If there's another way to do this or how to do it using a single function like:

byte[] toByteArray (variable-number of different-type parameters…)

Please let me know. Performance is an issue since the frequency of API calls is quite high.

Answer 1

I think you should try Google's Protocol Buffers: https://developers.google.com/protocol-buffers/

Protobuf is language-neutral. So you define your own structures and then generate specific code for Java, C#, C++, etc.

Answer 2

I opted for using the following code. Was initially concerned about the performance hit of using params and boxing/unboxing, but after some profiling it turns out to be negligible. Here it is for anyone who's interested.

    public static int ToByteArray (byte[] bytes, int Offs, params object[] args)
    {
        int CurrIdx = Offs;

        for (int i=0; i<args.Length; i++)
        {
            object obj = args[i];
            if (obj is int)
            {
                int x = (int) obj;
                bytes[CurrIdx++] = (byte)(x & 0xff);
                bytes[CurrIdx++] = (byte)((x >> 8) & 0xff);
                bytes[CurrIdx++] = (byte)((x >> 16) & 0xff);
                bytes[CurrIdx++] = (byte)((x >> 24) & 0xff);
            }
            else if (obj is double)
            {
                double x = (double)obj;
                System.Buffer.BlockCopy(BitConverter.GetBytes(x), 0, bytes, CurrIdx, sizeof(double));
                CurrIdx += sizeof(double);
            }
            else if (obj is string)
            {
                string x = (string)obj;
                int ByteLen = x.Length * sizeof(char);
                bytes[CurrIdx++] = (byte)(x.Length & 0xff);
                bytes[CurrIdx++] = (byte)((x.Length >> 8) & 0xff);
                System.Buffer.BlockCopy(x.ToCharArray(), 0, bytes, CurrIdx, ByteLen);
                CurrIdx += ByteLen;
            }
        }
        return (CurrIdx - Offs);
    }