Untitled

using System;
using System.Net.Sockets;
using System.IO;
using System.Text;
namespace x_bot
{
    class IrcClient
    {
        private NetworkStream Reader;
        private NetworkStream Writer;
        private TcpClient xBot;
        public bool Connected
        {
            get
            {
                return xBot.Connected;
            }
            protected set { }
        }
        public IrcClient(string server, int port)
        {
            xBot = new TcpClient();
            xBot.Connect(server, port);
            if (xBot.Connected)
            {
                Reader = xBot.GetStream();
                Writer = xBot.GetStream();
            }
        }
        private void Write(string data)
        {
            try
            {
                byte[] packet = Encoding.ASCII.GetBytes(data + "\r\n");
                Writer.Write(packet, 0, packet.Length);
                Console.WriteLine("Wrote -> {0}", data);
            }
            catch (Exception)
            { }
        }
        private bool NullOrEmpty(byte[] packet)
        {
            foreach(byte b in packet)
            {
                if((char)b != '\r' && (char)b != '\n' && (char)b != '\0')
                {
                    return false;
                }
            }
            return true;
        }
        private void Write(string data, params string[] args)
        {
            Write(String.Format(data, args)); 
        }
        private byte[] Read(int length)
        {
            try
            {
                byte[] packet = new byte[length];
                Reader.Read(packet, 0, packet.Length);
                if (NullOrEmpty(packet)) { return packet; }
                Console.WriteLine("Read -> {0}", Encoding.ASCII.GetString(packet));
                return packet;

            }
            catch (Exception)
            {
                return new byte[length];
            }
        }
        public void Nick(string nick)
        {
            Write("NICK {0}", nick);
        }
        public void Quit(string msg)
        {
            Write("QUIT :{0}", msg);
        }
        public void Notice(string target, string msg)
        {
            Write("NOTICE {0} :{1}", target, msg);
        }
        public void Msg(string target, string msg)
        {
            Write("PRIVMSG {0} :{1}", target, msg);
        }
        public void Join(string chan)
        {
            Write("JOIN {0}", chan);
        }
        public void Join(string chan, string key)
        {
            Write("JOIN {0} {1}", chan, key);
        }
        public void Pong(string server)
        {
            Write("PONG :{0}", server);
        }
        public void Part(string chan)
        {
            Write("PART {0}", chan);
        }
        public void Raw(string data)
        {
            Write(data);
        }
        public void User()
        {
            Write("USER {0} 0 * :{3}", Bot.RandString(8), Bot.RandString(8), Bot.RandString(8), Bot.RandString(8));
        }
        public string ReadLine()
        {
            return Encoding.ASCII.GetString(Read(1024));
        }
    }
}

    {
        public class IRCParsed
        {
            public string Prefix;

            public string Command;

            public List<string> Args = new List<string>();
        }

        public static IRCParsed ParseMessage(string s)
        {
            IRCParsed parsed = new IRCParsed();

            List<string> trailing = new List<string>();

            if (s.IndexOf(":") == 0)
            {
                string[] returned = s.Substring(1).Split(new char[] { ' ' }, 2);
                if (returned.Length > 1)
                {
                    parsed.Prefix = returned[0];
                    s = returned[1];
                }
            }

            if (!(s.IndexOf(" :") == -1))
            {
                string[] returned = s.Split(new string[] { " :" }, 2, StringSplitOptions.None);
                s = returned[0];
                trailing.Add(returned[1]);
                string[] split_args = s.Split(new char[] { ' ' }, StringSplitOptions.None);
                foreach (string arg in split_args)
                {
                    parsed.Args.Add(arg);
                }
                foreach (string trail in trailing)
                {
                    parsed.Args.Add(trail);
                }
            }
            else
            {
                foreach (string arg in s.Split(new char[] { ' ' }, StringSplitOptions.None))
                {
                    parsed.Args.Add(arg);
                }
            }

            parsed.Command = parsed.Args[0];
            parsed.Args.RemoveAt(0);

            return parsed;

        }
    }
}