C:/Users/Andreas Schiffler/Desktop/SVN/NewGamePhysics/NewGamePhysics/Networking/InfoLinkTransmitter.cs

//-----------------------------------------------------------------------------
// InfoLinkTransmitter.cs
// (A. Schiffler, 2009)
//-----------------------------------------------------------------------------

namespace NewGamePhysics.Networking
{
    using System;
    using System.Collections.Generic;
    using System.Net;
    using System.Net.Sockets;
    using System.Text;
    using System.Threading;

    public class InfoLinkTransmitter : InfoLinkNetBase
    {
        private const int PollingInterval = 1000;

        private const int TransmissionInterval = 100;

        private object syncRoot = new object();

        private List<InfoLink> transmitQueue = new List<InfoLink>();

        private volatile bool running = false;

        private Thread transmitterThread;

        private long transmitted;

        private long errors;

        public InfoLinkTransmitter()
        {
            this.port = InfoLinkNetDefaultPort;
        }

        public InfoLinkTransmitter(int port)
        {
            this.port = port;
        }

        public bool Running
        {
            get { return this.running; }
            set { this.running = value; }
        }

        public long Errors
        {
            get {
                return Interlocked.Read(ref this.errors);
            }
        }

        public long Transmitted
        {
            get
            {
                return Interlocked.Read(ref this.transmitted);
            }
        }

        ~InfoLinkTransmitter()
        {
            if (this.Connected)
            {
                this.Close();
            }
        }

        public void StartTransmitter()
        {
            if (this.Connected)
            {
                this.Close();
            }

            this.Open();
            this.transmitterThread = new Thread(new ThreadStart(RunTransmitterThread));
            this.transmitterThread.Name = "InfoLink Transmitter";
            this.transmitterThread.IsBackground = true;
            this.transmitterThread.Start();
        }

        public void StopTransmitter()
        {
            if (this.Connected)
            {
                this.Close();
            }
        }

        public void Transmit(InfoLink infoLink)
        {
            // Simply add the object to the queue for sending
            lock (syncRoot)
            {
                transmitQueue.Add(infoLink);
            }
        }

        public void Transmit(InfoLink[] infoLinks)
        {
            // Simply add the object to the queue for sending
            lock (syncRoot)
            {
                transmitQueue.AddRange(infoLinks);
            }
        }

        private void RunTransmitterThread()
        {
            this.running = this.Connected;

            while (this.running)
            {
                // Check if there is a new infoLink item in the queue
                InfoLink infoLink = null;
                lock (syncRoot)
                {
                    if (transmitQueue.Count > 0)
                    {
                        // Dequeue
                        infoLink = transmitQueue[0];
                        transmitQueue.RemoveAt(0);
                    }
                }

                // Maybe transmit
                if (infoLink != null)
                {
                    string message = InfoLinkSerializer.Serialize(infoLink);
                    byte[] sendbuf = Encoding.UTF8.GetBytes(message);

                    try
                    {
                        int bytesSent;

                        bytesSent = this.udpClient.Send(sendbuf, sendbuf.Length);
                        if (bytesSent == sendbuf.Length)
                        {
                            Interlocked.Increment(ref this.transmitted);
                        }
                        else
                        {
                            Interlocked.Increment(ref this.errors);
                        }
                    }
                    catch
                    {
                        Interlocked.Increment(ref this.errors);
                    }

                    // Pace packet transmission
                    Thread.Sleep(TransmissionInterval);
                }
                else
                {
                    // Poll slowly
                    Thread.Sleep(PollingInterval);
                }
            }
        }

        private void Open()
        {
            this.udpClient = new UdpClient();
            this.endPoint = new IPEndPoint(IPAddress.Broadcast, this.port);
            this.udpClient.EnableBroadcast = true;
            this.udpClient.Connect(this.endPoint);
            this.Connected = true;
            this.errors = 0;
        }

        private void Close()
        {
            try
            {
                this.running = false;
                this.udpClient.Close();
                this.transmitterThread = null;
            }
            finally
            {
                this.Connected = false;
            }
        }
    }
}

---