C++とかC#とか

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;

namespace NicoLive {
    public class Alert : IAlert {

        /// <summary>スレッド間同期に使用するロック用オブジェクト</summary>
        private object m_lock = new object();

        /// <summary>最新のコメントサーバー情報</summary>
        private ServerInfo m_serverInfo = null;

        /// <summary>コメントサーバー接続用ソケット</summary>
        private Socket m_socket = null;

        /// <summary>送受信に使用するバッファのバイト数</summary>
        private const int m_bufferSize = 1024;

        /// <summary>送受信に使用するバッファ</summary>
        private byte[][] m_buffer = new byte[4][]{
            new byte[1024],new byte[1024],new byte[1024],new byte[1024]
        };

        private int m_buffer_id = 0;

        /// <summary>接続が完了するのを待機するためのシグナルイベント</summary>
        private ManualResetEvent m_connectSignal = new ManualResetEvent(false);


        public event EventHandler<AlertEventArgs> LiveStarted = delegate(object s, AlertEventArgs e) {
        };

        /// <summary>
        /// 何らかのアクションが起こったときに通知するイベント
        /// 主にデバッグ用
        /// </summary>
        public event EventHandler<DebugEventArgs> Log = delegate(object s, DebugEventArgs e) {
        };

        /// <summary>
        /// コメントサーバーからデータを受信したときに発生するイベント
        /// リクエストに対するレスポンス、生放送開始の通知、ダミーデータ のいずれか(のはず)
        /// </summary>
        public event EventHandler<DebugEventArgs> Recieved = delegate(object s, DebugEventArgs e) {
        };

        /// <summary>
        /// コメントサーバーに接続中かどうかを表すフラグを取得する
        /// </summary>
        public bool Connected {
            get {
                return (m_socket != null) && m_socket.Connected;
            }
        }

        /// <summary>
        /// デフォルトコンストラクタ
        /// </summary>
        public Alert() {
            Recieved += new EventHandler<DebugEventArgs>(Alert_Recieved);
        }

        ~Alert() {
            Disconnect();
        }

        /// <summary>
        /// コメントサーバーに接続し、番組の開始を監視する
        /// </summary>
        /// <returns></returns>
        public bool Connect() {
            if (null != m_socket) {
                return false;
            }

            // サーバー情報を取得
            m_serverInfo = GetServerInfo();
            if (null == m_serverInfo || !m_serverInfo.Enabled) {
                return false;
            }

            OnLog("Request OK : " + OfficialApi.GetAlertInfo);
            OnLog("↪" + m_serverInfo.Addr + ":" + m_serverInfo.Port + " , " + m_serverInfo.Thread);

            StartRecieve();

            return true;
        }

        private bool StartRecieve() {
            OnLog("Listen");

            try {
                // ソケットの初期化
                m_socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

                m_connectSignal.Reset();
                // 接続
                IAsyncResult connectResult = m_socket.BeginConnect(m_serverInfo.Addr, m_serverInfo.Port, new AsyncCallback(ConnectCallback), m_socket);

                // 接続が成功するまで待機
                if (!m_connectSignal.WaitOne(5000, false)) {
                    // 失敗時
                    throw new Exception();
                }

                // 受信を待機
                RecieveBuffer reciever = new RecieveBuffer(1024);
                m_socket.BeginReceive(reciever.Buffer, 0, 1024, SocketFlags.None, new AsyncCallback(RecieveCallback), reciever);

                // リクエストを送信
                byte[] senddata = Encoding.UTF8.GetBytes("<thread thread=\"" + m_serverInfo.Thread + "\" version=\"20061206\" res_from=\"-1\"/>");
                m_socket.BeginSend(senddata, 0, senddata.Length, SocketFlags.None, new AsyncCallback(SendCallback), m_socket);
                m_socket.BeginSend(new byte[]{0}, 0, 1, SocketFlags.None, new AsyncCallback(SendCallback), m_socket);

            } catch{
                // エラー時
                OnLog("Socket error.");

                Disconnect();
                return false;
            }
            return true;
        }

        /// <summary>
        /// コメントサーバーへの接続コールバック
        /// </summary>
        /// <param name="connectResult"></param>
        private void ConnectCallback(IAsyncResult connectResult) {
            Socket socket = (Socket)connectResult.AsyncState;
            if (socket != null) {
                OnLog("Connect OK.");
                // 接続の成功を通知
                m_connectSignal.Set();
            }
        }

        /// <summary>
        /// 受信コールバック
        /// </summary>
        /// <param name="readResult"></param>
        private void RecieveCallback(IAsyncResult readResult) {
            //readResult.
            Socket socket = m_socket;
            //int buffer_id = (int)readResult.AsyncState;
            RecieveBuffer reciever = readResult.AsyncState as RecieveBuffer;

            if (null == socket || !socket.Connected) {
                // 切断済みの場合
                OnLog("Socket Already Disconnected.");
                return;
            }
            reciever.Bytes = socket.EndReceive(readResult);

            if (reciever.Bytes > 0) {
                OnLog("Recieved " + reciever.Bytes + "bytes. ");

                reciever.Analyze();

                int i = 0;
                foreach (string r in reciever.LineString) {
                    OnLog("Recieved("+ i++ +"):" + r);
                    AlertEventArgs args = Analyze(r);
                    OnRecieved(r);
                }
                // 引き続き受信を待機する
                RecieveBuffer nextreciever = new RecieveBuffer(1024);
                socket.BeginReceive(nextreciever.Buffer, 0, 1024, SocketFlags.None, new AsyncCallback(RecieveCallback), nextreciever);
            } else {
                OnLog("Recieve Failed.");
                Disconnect();
            }
        }

        private AlertEventArgs Analyze(string xml) {
            AlertEventArgs args = new AlertEventArgs();
            args.Original = xml;
            Match match = Regex.Match(xml, ">(.+),(.+),(.+)<");
            if (match.Success) {
                args.LiveId = match.Groups[1].Value;
                args.Community = match.Groups[2].Value;
                args.User = match.Groups[3].Value;
            }
            return args;
        }

        /// <summary>
        /// 送信コールバック
        /// </summary>
        /// <param name="sendResult"></param>
        private void SendCallback(IAsyncResult sendResult) {
            Socket socket = (Socket)sendResult.AsyncState;
            try {
                int sendbytes = socket.EndSend(sendResult);
                if (sendbytes > 0) {
                    OnLog("Send OK.");
                } else {
                    throw new ApplicationException();
                }
            } catch {
                OnLog("Send Error.");
                Disconnect();
            }
        }

        /// <summary>
        /// コメントサーバーに接続中であれば切断する
        /// </summary>
        public void Disconnect() {
            if (null == m_socket) {
                return;
            }
            try {
                m_socket.Shutdown(SocketShutdown.Both);
            } finally {
                m_socket.Close();
                m_socket = null;
                OnLog("Disconnected.");
            }
        }

        /// <summary>
        /// Logイベントを発行する
        /// </summary>
        /// <param name="log"></param>
        protected void OnLog(string log) {
            Log(this, new DebugEventArgs(log));
        }

        /// <summary>
        /// Recievedイベントを発行する
        /// </summary>
        /// <param name="recievedString"></param>
        protected void OnRecieved(string recievedString) {
            Recieved(this, new DebugEventArgs(recievedString));
        }

        /// <summary>
        /// Recievedイベントを発行する
        /// </summary>
        /// <param name="recievedData"></param>
        /// <param name="bytes"></param>
        protected void OnRecieved(byte[] recievedData, int bytes) {
            OnRecieved(Encoding.UTF8.GetString(recievedData, 0, bytes));
        }

        /// <summary>
        ///
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void Alert_Recieved(object sender, DebugEventArgs e) {

            AlertEventArgs args = Analyze(e.Text);
            if (args.LiveId != "") {
                LiveStarted(this, args);
            }
        }

        /// <summary>
        /// コメントサーバーの情報を取得する
        /// </summary>
        /// <returns></returns>
        private ServerInfo GetServerInfo() {
            var result = new ServerInfo();

            try {
                WebRequest request = WebRequest.Create(OfficialApi.GetAlertInfo);
                WebResponse response = request.GetResponse();
                Stream stream = response.GetResponseStream();

                if (stream != null) {
                    StreamReader reader = new StreamReader(stream, Encoding.UTF8);
                    string data = reader.ReadToEnd();
                    stream.Close();

                    Match match = Regex.Match(data, "<addr>(.+)</addr>");
                    if (match.Success) {
                        result.Addr = match.Groups[1].Value;
                    }
                    match = Regex.Match(data, "<port>(.+)</port>");
                    if (match.Success) {
                        result.Port = int.Parse(match.Groups[1].Value);
                    }
                    match = Regex.Match(data, "<thread>(.+)</thread>");
                    if (match.Success) {
                        result.Thread = match.Groups[1].Value;
                    }
                }
                response.Close();
            } catch {
                return null;
            }
            return result;
        }

        /// <summary>
        /// 指定された番組のURLを取得する
        /// </summary>
        /// <param name="liveId"></param>
        /// <returns></returns>
        public static Uri GetLiveUri(int liveId) {
            return GetLiveUri(liveId.ToString());
        }

        /// <summary>
        /// 指定された番組のURLを取得する
        /// </summary>
        /// <param name="liveId"></param>
        /// <returns></returns>
        public static Uri GetLiveUri(string liveId) {
            // "lv"から始まっていない場合"lv"を付ける
            string livepart = liveId.StartsWith("lv") ? liveId : ("lv" + liveId);
            return new Uri("http://live.nicovideo.jp/watch/" + livepart + "?alert=2");
        }
    }
}