List<byte> -> string -> List<byte>

List<byte> lstBytes;
...
...

lstBytes.ToArray(); // will give you a byte array

The class below should help.. You can call the ToArray method of your list or you can modify the class below to accept a List<byte>.

public class BinUtil
{
private static readonly string[] HexDigits =
{
"00", "01", "02", "03", "04", "05", "06", "07", "08", "09", "0A", "0B", "0C", "0D", "0E", "0F",
"10", "11", "12", "13", "14", "15", "16", "17", "18", "19", "1A", "1B", "1C", "1D", "1E", "1F",
"20", "21", "22", "23", "24", "25", "26", "27", "28", "29", "2A", "2B", "2C", "2D", "2E", "2F",
"30", "31", "32", "33", "34", "35", "36", "37", "38", "39", "3A", "3B", "3C", "3D", "3E", "3F",
"40", "41", "42", "43", "44", "45", "46", "47", "48", "49", "4A", "4B", "4C", "4D", "4E", "4F",
"50", "51", "52", "53", "54", "55", "56", "57", "58", "59", "5A", "5B", "5C", "5D", "5E", "5F",
"60", "61", "62", "63", "64", "65", "66", "67", "68", "69", "6A", "6B", "6C", "6D", "6E", "6F",
"70", "71", "72", "73", "74", "75", "76", "77", "78", "79", "7A", "7B", "7C", "7D", "7E", "7F",
"80", "81", "82", "83", "84", "85", "86", "87", "88", "89", "8A", "8B", "8C", "8D", "8E", "8F",
"90", "91", "92", "93", "94", "95", "96", "97", "98", "99", "9A", "9B", "9C", "9D", "9E", "9F",
"A0", "A1", "A2", "A3", "A4", "A5", "A6", "A7", "A8", "A9", "AA", "AB", "AC", "AD", "AE", "AF",
"B0", "B1", "B2", "B3", "B4", "B5", "B6", "B7", "B8", "B9", "BA", "BB", "BC", "BD", "BE", "BF",
"C0", "C1", "C2", "C3", "C4", "C5", "C6", "C7", "C8", "C9", "CA", "CB", "CC", "CD", "CE", "CF",
"D0", "D1", "D2", "D3", "D4", "D5", "D6", "D7", "D8", "D9", "DA", "DB", "DC", "DD", "DE", "DF",
"E0", "E1", "E2", "E3", "E4", "E5", "E6", "E7", "E8", "E9", "EA", "EB", "EC", "ED", "EE", "EF",
"F0", "F1", "F2", "F3", "F4", "F5", "F6", "F7", "F8", "F9", "FA", "FB", "FC", "FD", "FE", "FF"
};

/// <summary>
/// Determines if specified string is a hexadecimal string.
/// </summary>
/// <param name="hexString">string to check</param>
/// <returns>Boolean indicating whether or not the specified string is a hexadecimal string</returns>
/// <remarks>"00FF0A12" is an example of a hexadecimal string</remarks>
public static bool IsHexString(string hexString)
{
if (hexString == null || ((hexString.Length % 2) != 0))
{
return false;
}

foreach (char c in hexString)
{
if (!Uri.IsHexDigit(c))
{
return false;
}
}

return true;
}

/// <summary>
/// Converts a byte array to a hexadecimal string representation.
/// </summary>
/// <param name="bytes">Array to be converted</param>
/// <returns>Hexadecimal string</returns>
public static string ToHexString(byte[] bytes)
{
StringBuilder retVal = new StringBuilder(bytes.Length * 2);
for (int i = 0; i < bytes.Length; i++)
{
retVal.Append(HexDigits[bytes[i]]);
}

return retVal.ToString();
}

/// <summary>
/// Converts a byte array to a hexadecimal string representation with specified separator after every byte.
/// </summary>
/// <param name="bytes">Array to be converted</param>
/// <param name="separator">Separator to add after each byte</param>
/// <returns>Hexadecimal string</returns>
public static string ToHexString(byte[] bytes, string separator)
{
StringBuilder retVal = new StringBuilder((bytes.Length * 2) + (separator.Length * bytes.Length));
for (int i = 0; i < bytes.Length; i++)
{
retVal.Append(HexDigits[bytes[i]]);
retVal.Append(separator);
}

return retVal.ToString();
}

/// <summary>
/// Converts a section of a byte array to a hexadecimal string representation.
/// </summary>
/// <param name="bytes">Array to be converted</param>
/// <param name="offset">The location in bytes array from which to start converting data</param>
/// <param name="length">The number of bytes to convert</param>
/// <returns>Hexadecimal string</returns>
public static string ToHexString(byte[] bytes, int offset, int length)
{
StringBuilder retVal = new StringBuilder(length * 2);

for (int i = 0; i < length; i++)
{
retVal.Append(HexDigits[bytes[offset + i]]);
}

return retVal.ToString();
}

/// <summary>
/// Converts a section of a byte array to a hexadecimal string representation with specified separator after every byte.
/// </summary>
/// <param name="bytes">Array to be converted</param>
/// <param name="offset">The location in bytes array from which to start converting data</param>
/// <param name="length">The number of bytes to convert</param>
/// <param name="separator"></param>
/// <returns>Hexadecimal string</returns>
public static string ToHexString(byte[] bytes, int offset, int length, string separator)
{
StringBuilder retVal = new StringBuilder((bytes.Length * 2) + (separator.Length * bytes.Length));

for (int i = 0; i < length; i++)
{
retVal.Append(HexDigits[bytes[offset + i]]);
retVal.Append(separator);
}

return retVal.ToString();
}

/// <summary>
/// Convert a hexadecimal string to a byte array.
/// </summary>
/// <param name="hexString">Hexadecimal string to convert</param>
/// <returns>byte array</returns>
public static byte[] ToByteArray(string hexString)
{
byte[] retVal = new byte[0];

if (!IsHexString(hexString))
{
throw new ArgumentException("Error: Illegal hex string. " + hexString);
}

retVal = new byte[hexString.Length / 2];

for (int i = 0; i < retVal.Length; i++)
{
retVal[i] = Convert.ToByte(hexString.Substring(i*2, 2), 16);
}

return retVal;
}
}

BitConverter is *definately* the way to go as opposed to using the code above. However, sockets prefer byte[] when sending data, so why not just send the array itself?

Is the receiving app on the other side of the socket a .net or Java app?

This is actually two different commands to my client, but for some reason they randomly get concat, it doesn't happen very often, but it shouldn't happen at all.

000401000507 (this should really be two commands)

command 1: 000401 (which means they are connected to the server, and their client id = 1)

command 2: 000507 (which means load message 07 from the resource file and display it)

The first 4 bytes are always the command, and the rest is the command data. They are both converted to enums. Its a lot better then sending the actual data or a very long string.

They are not concat when the leave the server, only when they arrive at the client, my BetaLogger will prove that. Do you think this is caused from the OUT params I am using in the OnDataReceived method? Are these not thread safe?

--
edited
--

I have confirm that this appears to be because the messages are being sent to the client too fast. This has to be what is happening. I have been testing for hours, and I cannot see any other reason for this to happen.

So I thought about making a queue system to only send 1 message per second to each client but that will not work. I would need to do the same on the server side because the server will have an extrem amount of client connections. I can't really to this queue in reverse.

It looks like my best option is to stick with the size option. I need to send the size with the string, I can send it as the first four bytes, this is not a problem for me. But I cannot figure out how to get it on the other side. I need to get the size from the first 4 bytes of the string, read that command and then all remaining bytes are pushed the next command.

Its possible I know, but I cannot figure out how to do it, because on my OnReceived method it reads the data in, and doesn't really allow me a place to grab size data before reading anything. I can't get the size data until I've read the string.

My string could be like this

001200010009

first 4: 12 bytes to read, 2nd 4: command, 3rd 4: command data

My string may not always be that simple however, command data may not always be 4 bytes, the rest will always be four bytes. I will never need to send a string larger then 9999 bytes. I will never even get close to that. All my strings are actually stored in the client, I just send the ID of the string that the client needs to load.

I will look into it in the mean time. If I can get every single message to be the exact same size coming over the network kind of like a HASH, then I will always know how many bytes to read. Problem is I cannot reverse a hash so I have no way to know what the original message was. I think I can try to get something working,

problem is sending that array byte bytes, I still have no idea how to do that, and I cannot gurantee how many bytes will be in that array. That will toss my fixed command length right out the door.

--

Well this is all I can come up with, bitConverter does not with with a List<byte> for some stupid reason. This works but it is very slow. I cannot use it.


byte[] bteList = new byte[100];

for(byte i = 0; i < 100; i++) {

bteList[i] = i;

}

for(byte i = 0; i < bteList.Length; i++) {

listBox1.Items.Add(bteList[i]);

}

string bytes = Convert.ToBase64String(bteList);

textBox1.Text = bytes;

byte[] bteList2 = Convert.FromBase64String(bytes);

for(byte i = 0; i < bteList2.Length; i++) {

listBox2.Items.Add(bteList2[i]);

}

i dont know what your talking about. what is a web service? i am building a windows game.

regardless it seems impossible. even when i send a fixed string of 8 bytes its impossible to work correctly because they are async methods and it seems one thread always steps on another thread and this causing the issue. There is nothing I can do to prevent a thread from walking on another thread.

I thought there was a LOCK command or something...?? I don't know but I'm tired and I'm going to bed. Do you know of a lock command? Does that prevent a thread from using a method until its unlocked, and then that thread can use it? kind of like queuing the threads?

thanks

Thanks Mutant_Fruit. I am not going to give up even as I've been stuck on this for a week. I know it has to be possible. I think you are right. I think I know what happening now because I have a few methods in my server one that sends to all clients and one that sends to a single client. It appears that these are stepping on each other. If I can move them into one single method, then control it with the lock statement I think it will be less likely for them to do that, then I will try to send the size before my transmission.

I am going to get this working no matter how long it takes. I'll be working on it today. I'll post back when I find a solution, or if I run into any more problems. I think I kinda understand what is going on now.

Thanks.

i dont know what your talking about. what is a web service? i am building a windows game.

regardless it seems impossible. even when i send a fixed string of 8 bytes its impossible to work correctly because they are async methods and it seems one thread always steps on another thread and this causing the issue. There is nothing I can do to prevent a thread from walking on another thread.

I thought there was a LOCK command or something...?? I don't know but I'm tired and I'm going to bed. Do you know of a lock command? Does that prevent a thread from using a method until its unlocked, and then that thread can use it? kind of like queuing the threads?

thanksSorry, I misread '.net windows service' as '.net web service'.
There are lock commands in .net. If you need multiple readers, check out the ReaderWriterLock class. If you would like a RAII approach to locking, check out the IDisposable and Using block (http://www.dev-archive.com/forum/showthread.php?t=436753) thread.

You can't send 'objects' via a socket. You can only send 'bytes'. If you want to send information via a socket, it has to be convertible to an array of bytes (through whatever means you want to use) and then convertible from an array of bytes back into the original object,

There are dozens of tutorial documents on how to build a simple webserver that sends text to and from client's connected to the server. Some of them should be helpful. Google for 'c# socket tutorial'.

I've been using google for a week there are not any good examples. I have tried hundreds of code changes and nothing works. Not one of them show you how to send the size of an object, and then read it on the other side. I don't think that's the correct solution. I tried that several times and it still combines many commands into one.

I don't really think its possible. I have tried to serialize objects, that doesn't do any good because the objects still run on top of each other and they are corrupt on the other side. It is impossible to tell where one object stops and another one stops, sending the size before it does not help.

OK, here's a really simple example.

Client and server are sending/receiving strings.

Client has a string 'ClientString'.
Client wants to send this to the server through a socket.
Client first sends the length of the string: socket.Send(ClientString.Length);
Client then sends the string: socket.Send(System.Text.Encoding.UTF8.GetBytes(ClientString));

Client then sends a second string, ClientString2 in the same manner.

Server reads one int from the socket: int length = socket.ReadInt();
server now knows how much data it needs to read to retrieve.
Server reads 'length' bytes from the socket: byte[] data = socket.Read(length);
Server converts back to string from: string ClientString = System.Text.Encoding.UTF8.GetString(data);

Server now reads one int again: int length = Socket.ReadInt();
Server now knows the length of the second string.
Server reads the second string: byte[] data = socket.Read(length);
Server converts back to string form: string ClientString2 = System.Text.Encoding.UTF8.GetString(data);

You have now successfully received two string which were sent at the same time without screwing it up.

Note: You can't just send an 'int' through a socket. Sockets need a byte[], so you can use BitConverter.GetBytes(myInt) to convert the int to a byte[]. Alternatively, you could wrap your socket in a NetworkStream, which makes it much easier to use.

The patten works, it is the solution. Just because you can't make the solution work doesn't mean it's not the right solution.

The messages still overlap, what did I do wrong??Try moving to a console app and work with a single client based on Mutant's code until you get that working. Then move to multi-client.

I'm just going to rip out my hair.

I will try but the solution is not so simple because everyone is missing the fact I am working with Asynchronous Sockets. So when I send two seperate commands like that, one with size data and one with the real command they get mixed up between threads from time to time. If one thread send a size data and another thread sends a message, it uses the wrong size data to read the wrong message.

I cannot use Synchronous sockets because I need to have many clients connected at the same time and it would never work. That example makes it sound so simple, and it would be if I was using Synchronous Sockets.

I know what you are saying but there has to be some way to control it.Can you send the size and the data as part of a single message? In other words prepend the size in the byte array you are sending (kind of like the way a BSTR does it). On the receiving end you would look at the first 4 bytes to determining the overall length.

[Edit] After rereading previous posts, looks like you may have already tried this.

See my code in post # 13.

I already tried that but I didn't know how to read the data in on the other side so I had to give up.Since you are storing it in a string couldn't you just do a SubString on the first few characters and then convert to an int? Then read the rest of the data?

AHHHHHHH :wave:

OK! Seems to be working finially. I figured out what I was doing wrong. I am not losing any messages now, even when I send a lot, and they are all complete. My server sends all messages from one method that is not threaded. The client still recieves Async messages but it doesn't matter because the server only sends them sync. But this still allows the client to send a message at the same time its receiving a message.

I do have a few questions though. Maybe why I was getting confused.

#1. How come when I get the bytes of an int32 no matter what the number is, the bytes length is always 4? I was trying to add this myself with ToString("0000") so that the int would be 4 bytes. I didn't know I didn't have to do that until I created a test program


private void button1_Click(object sender, EventArgs e) {
byte[] size = BitConverter.GetBytes(Convert.ToInt32(textBox1.Text));
listBox1.Items.Clear();
for(int i = 0; i < size.Length; i++) {
listBox1.Items.Add(size[i]);
}


#2. I'm still having a few problems sending the List<byte>. My program crashes when I try to send it, and I cannot debug a windows service for some reason, I only have express edition I think that's why.

I need to append the 4 byte network command to the front of the list, so I am trying to do that with Array.Copy. I'm not sure if I'm on the right track or not, but I can't figure out how to concat two byte[]'s. This is how I am writting the network bytes


// CONCATENATES A SPECIAL COMMAND FOR A CLIENT, THIS IS NOT REALLY A STRING.
public static byte[] WriteNetworkString(NetCommandType cmdType, byte[] cmdData) {
byte[] cmdTypeBytes = Encoding.ASCII.GetBytes(((int)cmdType).ToString("0000"));
byte[] networkBytes = new byte[cmdTypeBytes.Length + cmdData.Length];
Array.Copy(cmdTypeBytes, 0, networkBytes, 0, cmdTypeBytes.Length);
Array.Copy(cmdData, 0, networkBytes, (cmdTypeBytes.Length + 1), cmdData.Length);
return networkBytes;
}


Then I have a reader that will take it apart again. I try to keep all this stuff seperate from the network code so its in a helper class for my games network methods.

#3. I have solved this in one direction, now in the other direction I will have a problem because I cannot control when clients will send data, and a lot of clients may send data at one time. So to prevent this issue on commands stepping on each other. I plan to use the exact same method, only I was thinking I could store the data in a Hashtable. With the client ID as the key and the int size as the data.

This way I will make sure that one client's size data does not get used to read another clients transmission. I use a single private int on the client side, but that's not going to be good enough for a server, because I'm sure other clients will overwrite that size data before the client has a chance to send its data, and the server will read in a lot of threads. I noticed that I can make a hashtable thread syncronized by setting its property, so it should work out good.

Am I on the right track now for the server?

Clients are working, and updating automatically by the windows service which controls the game :) http://kensino.com/images/Untitled.jpg. These are just test boxes, the real UI isn't 100% complete yet. These help me test the code without bringing in exisiting errors from the UI's code. If these fail I know its a problem with the network code.

Also I have been trying to follow all the rules for OOP. I have been making all my variables camel case, my private fields prefexed with a m_, all consts are in upper case and I never use numbers in my code. I always assign a name to the number by making it a const, so it makes my code more readable. I'm think I am getting the hang of this. I hate bingo but this program is an excellent learning expierence. It uses a lot of different types of programming, and once its working I'll need to use MS SQL to store user stats, and accounts.
http://kensino.com/images/Untitled2.jpg

I even found a cool way to have an enum push my game along by a threading timer.


using System;
namespace BingoEngine {
// THE SPEED AT WHICH THE GAME WILL BE PUSHED, IN SECONDS.
public enum GameSpeed {
// THIS SETS THE AMOUNT OF TIME BETWEEN NUMBER CALLS
Fast = 4000, // FOUR SECONDS
Normal = 8000, // EIGHT SECONDS
Slow = 10000, // TEN SECONDS
VerySlow = 15000, // FIFTEEN SECONDS
BetaMode = 1500 // DO NOT USE THIS MODE
}
}


So does it seem like I'm getting a hang of using C#? There is a lot I don't know but my code is getting better and better, and more concise. I do a lot of things now with one statement that I use to do in several. My code seems to be getting a lot more advanced as well.