发送字节数组和字符串的流（用于网络）

Question

I'm searching for a Streamclass which contains: - a method for sending/receiving a byte-array - a method for sending/receiving a string

The only Class I've found was NetworkStream. But the disadvantage with the NetworkStream-Class is, that if i want sending a string, i must befor convert this string into a byte-array and send this byte-array, because there is no method for sending strings directly. And on the other side classes like Streamwriter have methods for sending/receiving strings, but there have no methods for sending/receiving a byte-array.

And if i try to combine these two Streamclasses like this:

TcpClient clientConnection = new TcpClient();
NetworkStream nws = clientConnection.GetStream();
StreamWriter sw = new StreamWriter(nws);
sw.writeLine("ABC");
sw.Flush();
nws.Write(byteArray, 0, lengthToSend);

i get a lot of strange errors (like byteArray will not receive on the other side completly), because i'm using here the same one stream in two different ways.

So, must i used NetworkStream-Class for my plan or exists there a better way?

Answer 1

I had the same problem,and the point is that the other side doesnt know what you are sending byte array or string so what i did is putting a header for each msg specially when dealing with serious server/client application coz you will have multiple data (user info, requesting info,replying info .. etc)

i am using streamwriter to send and streamreader to receive but i am also using threads the connection remains open as long as the client is connected so i declare them once

here is a full example of my codes

public class Client
{
    private StreamWriter swSender;
    private StreamReader srReceiver;
    private TcpClient tcpServer; 
    private Thread thrMessaging;
    private string UserName = "UK";
    private byte Tries = 0;
    private bool Connected = false;
    public void Connect()
    {
        if (!Connected)
        {
            IPAddress[] localIPs = Dns.GetHostAddresses(Dns.GetHostName());
            string User = localIPs[0].ToString();
            string ServIP = "127.0.0.1";//change this to your server ip
            InitializeConnection(ServIP, User);
        }
        else
        {
            CloseConnection("Disconnected at user's request.");
        }
    }
    private void InitializeConnection(string ServIp, string User)
    {
        IPAddress ipAddr = IPAddress.Parse(ServIp);
        tcpServer = new TcpClient();
        try
        {
            tcpServer.Connect(ipAddr, 1986);//change that 1986 to your server port
        }
        catch 
        { 
        if (Connected) CloseConnection("");
        MessageBox.Show("Connecteing to " + ServIp + "\r\nServer is Down ... Try nomber " + Tries); return; 
        }
        Connected = true;
        UserName = User;
        swSender = new StreamWriter(tcpServer.GetStream());
        swSender.WriteLine(User);
        swSender.Flush();
        thrMessaging = new Thread(new ThreadStart(ReceiveMessages));
        thrMessaging.Start();
    }
    private void ReceiveMessages()
    {
        srReceiver = new StreamReader(tcpServer.GetStream());
        string ConResponse = srReceiver.ReadLine();
        if (ConResponse[0] == '1')
        {


        }
        else
        {
            string Reason = "Not Connected: ";
            Reason += ConResponse.Substring(2, ConResponse.Length - 2);
            return;
        }
        while (Connected)
        {
            try
            {
                string NewMsg = srReceiver.ReadLine();
                if (NewMsg != null && NewMsg != "")
                    PacketHandler.HandlePacket(NewMsg, this);

            }
            catch {  }
        }
    }
    public void CloseConnection(string Reason)
    {
        try
        {
            Connected = false;
            swSender.Close();
            srReceiver.Close();
            tcpServer.Close();
        }
        catch { }
    }
    public void SendMessage(string Msg)
    {
        if (Msg.Length >= 1)
        {
            try
            {
                Tries++;
                swSender.WriteLine(Msg);
                swSender.Flush();
                Tries = 0;
            }
            catch
            {
                if (Tries < 5)
                {
                    try
                    {
                        CloseConnection("No connection made");
                        Connect();
                    }
                    catch { }
                    SendMessage(Msg);
                }
                else { MessageBox.Show("Connecting to server faild for 5 tries"); Tries = 0; }
            }
        }
    }

then at the packet handler i do my handling to check what kind of data the client received

something like this

public static void HandlePacket(string MsgRec, Client Client)
    {
        string[] Info = MsgRec.Split('|');
        string Type = Info[0];
        if (Type == "")
        {
            return;
        }
        string subtype = Info[1];
        int TLen = Type.Length + subtype.Length + 2;
        string Data = MsgRec.Remove(0, TLen);//this is the main data the server sent
        ushort PacketType = ushort.Parse(Type);
        ushort SubType = ushort.Parse(subtype);
        switch ((Structs.PacketType)PacketType)
        {
            case Structs.PacketType.Login:
                {
                 //do your stuff here
                 break
                }

            case Structs.PacketType.Image:
                {
                 //convert the Data back to byte array then get the image out from it
                 break
                }
            case Structs.PacketType.ByteArray:
                {
                 //convert the Data back to byte array
                 break
                }
        }
    }

i know its kinda messy and not the perfect way to do it , but it works for me and remember that at the other side when sending something you need to add the packet type and subtype , or just any header with any splitter if u doin something simple

Finally : i think using Sockets and packets would be much easier if u are sending small packets length