Question

I am trying to learn udp sockets etc…. I created two programs server and client. The client sends a packet to the server, the server bounces it back.

This is the code I use in both programs for converting the data to and from a byte[]

but I am getting an error when converting from byte[]

public static Packet Open(byte[] b)
        {
            MemoryStream memStream = new MemoryStream();
            BinaryFormatter binForm = new BinaryFormatter();
            memStream.Write(b, 0, b.Length);
            memStream.Seek(0, SeekOrigin.Begin);
            object obj = new object();
            try
            {
                // this line here is where the error is occurring
                obj = (object)binForm.Deserialize(memStream);
            }
            catch (Exception er)
            {
                MessageBox.Show(er.Message);
            }
            if (obj is Packet)
                return (Packet)obj;
            else
                return null;
        }

        public byte[] Bundle()
        {
            BinaryFormatter bf = new BinaryFormatter();
            MemoryStream ms = new MemoryStream();
            bf.Serialize(ms, this);
            return ms.ToArray();
        }

If I do this, all from one program it works

Packet p =new Packet();
p.Message="hello";

byte[] data = p.Bundle();

Packet p2 = Packet.Open(data);
MessageBox.Show(p2.Message);

The error I am receiving is “unable to find assembly in “the name of my client program”

AnyIdeas?

Answer 1

It sounds to me like you are serializing a type that is not shared via a reference between both ends. Note: it is not sufficient to have the same class compiled into both, since BinaryFormatter includes the full type name including the assembly, so: it will still count as an unrelated type. The common fix there (and I use the word “fix” entirely incorrectly) is to write an assembly for the DTO and reference that assembly from both client and server. This approach still has many issues, though.

For info, there are other serializers that are compatible with just having a similar class at each end. I’m biased, but I would suggest having a look at protobuf-net; the output is usually significantly smaller, and it isn’t tied to the type, meaning the class just has to be broadly similar at each end (it is very version tolerant). Plus it is faster (CPU-wise) too!