asynchronous socket problem

[Lynne]

I am using the C# asynchronous socket functionality for a server, and
it appears to work fine if I just receive data and echo it back to the
client. The problem occurs when I try to handle sending data
independent of a receive. The send happens just fine, but when I
receive the next set of data from the client (in a size, size, data
set of packets), I lose however many packets of data I sent. For
example, a normal client send would include 3 separate packets of
data (p1-4 bytes, p2-4 bytes, p3-however many bytes are represented by
the size in p1). The server then echoes back the same data.

After sending one packet of data independent of receiving data, the
client sends the same 3 packets of data. However, the receive
callback is only entered twice.

It seems to be related to the beginReceive function, but I can't
figure out how. Prior to calling the sendTest, I have started a
beginReceive. Is this ended when I send data? I've tried adding a
beginReceive after the send, but this doesn't appear to help. Any
assistance would be greatly appreciated!

public void send(SocketData data)
{
SocketState ss = (SocketState)co nnectionTable[
data.getSocketH andle()];
send(ss, data.getXmlStri ng());
clearSocketStat e(ref ss);
}

/// <summary>
/// This function creates a callback to send data.
/// </summary>
/// <param name="handler"> The socket state from which to get
the
/// socket to send data.</param>
/// <param name="data">The data to send</param>
public void send(SocketStat e handler, string data)
{
// Convert the string data to byte data using big endian
encoding.
byte[] byteData = Encoding.ASCII. GetBytes(data);

byte[] sizeBytes =
BitConverter.Ge tBytes((int)byt eData.Length);
byte[] compressedBytes =
BitConverter.Ge tBytes((int)byt eData.Length);
if(byteData.Len gth > compressionSize )
{
// compress the data
//recalculate the compressed byte length
compressedBytes =
BitConverter.Ge tBytes((int)byt eData.Length);
}

byte[] sendBytes = new byte[byteData.Length +
sizeBytes.Lengt h +
compressedBytes .Length];

// Add bytes for size and compressed size to the message
to be sent
sizeBytes.CopyT o(sendBytes, 0);
compressedBytes .CopyTo(sendByt es, sizeBytes.Lengt h);
byteData.CopyTo (sendBytes, sizeBytes.Lengt h +
compressedBytes .Length);
handler.buffer = sendBytes;
printBytes(send Bytes.Length, ref handler);
// Begin sending the data to the remote device.
handler.theSock et.Send(sendByt es);
//TODO: remove this after testing
Console.WriteLi ne("Sent {0} bytes to client.",
sendBytes.Lengt h);

}
public void sendTest()
{
Console.WriteLi ne("sendTest entry point");

try
{

while(connectio nTable.Count == 0)
{
// just spin here until there is a connection
}

IEnumerator ie = connectionTable .Keys.GetEnumer ator();
ie.MoveNext();
SocketState ss =
(SocketState)co nnectionTable[ie.Current];
IntPtr si = ss.theSocket.Ha ndle;
SocketData data = new SocketData(si," testSend Data");
send(data);
data.setXmlStri ng("testSend Data1");
// send(data);
data.setXmlStri ng("testSend Data2");
// send(data);
}
catch (Exception e)
{
Console.WriteLi ne("Exception occurred: {0}, stack
trace {1}",
e.Message, e.StackTrace);
}

Console.WriteLi ne("Done");
}