Hi Chris,

            Im already doing the number one, low scalability, on the UDP im
doing that doesnt receive or process the entire messages. Since im still a
newbie here i cant really get the idea on the number 2.. Would you care to
explain? If its okay with you that is.. Begin/End are methods of Socket
right? Im not using any socket, both my receiving and seding is using
UDPClient. Thank You so much!

-------------My OnConnect and OnReceive Events Mthods-----------------

        private void Client_OnConnect( string msg )
        {
            FileLogger  Log =  FileLogger.New;
            Log.AppendToLogFile("Connected.");
            Console.WriteLine( "Connected.");
        }
        private void Client_OnRecieve( string msg )
        {

            FileLogger  Log =  FileLogger.New;
            Log.AppendToLogFile( msg );
            Console.WriteLine(msg);
        }

--------------My Multicasting code:-------------------------------

namespace DigiSoft.Multicasting
{
    /// <summary>
    /// Summary description for Multicasting.
    /// </summary>
    ///
    public delegate void OnRecieveDataEventHandler( string Message );
    public delegate void OnConnectEventHandler(string Message );
    public delegate void OnDisconnectEventHandler( string Message );
    public delegate void OnErrorEventHandler( string errorMsg );

    public class Multicasting
    {
        //Properties
        public string MulticastGroup
        {
            get { return mygroupAddress; }
            set { mygroupAddress = value; }
        }

        public int groupPort
        {
            get { return mygroupPort; }
            set { mygroupPort = value; }
        }

        public int TTL
        {
            get { return myTTL; }
            set { myTTL = value; }
        }

       
        private UdpClient thisClient;
        private IPEndPoint RemoteEndPoint;
        private string mygroupAddress;
        private int mygroupPort;
        private int myTTL;
        private bool done;
        private bool isRunning = false;

        public void Start()
        {
            try
            {
                UdpClient udp = AsyncState as UdpClient;
                thisClient= new UdpClient( mygroupPort );
                thisClient.JoinMulticastGroup( IPAddress.Parse(mygroupAddress), myTTL );
                RemoteEndPoint = new IPEndPoint(IPAddress.Parse(mygroupAddress),
mygroupPort);
           
                Thread myThread = new Thread( new ThreadStart( this.Listen ));
#if !CF
                myThread.IsBackground = true;
#endif
                myThread.Start();
                isRunning = true;

                if ( OnConnect != null)
                    OnConnect(string.Empty );
               
                //send whereabouts to the group
                byte[] bs = System.Text.Encoding.UTF8.GetBytes( Dns.GetHostByName(
Dns.GetHostName()).AddressList[0].ToString() + " has joined." ) ;
                thisClient.Send(bs,(int) bs.Length, RemoteEndPoint);

            }
            catch(Exception e)
            {
                //Some error Message;
                if(OnError!=null)
                    OnError("Error Connecting : " + e.Message);
                done = true;
                isRunning = false;
            }
        }

        private void Listen()
        {
            done = false;
            while(!done)
            {

                try
                {
#if !CF
                    IPEndPoint IPEndPointNull = null;
#else

                    IPEndPoint IPEndPointNull = new IPEndPoint( IPAddress.Any,
this.mygroupPort );
#endif
                    byte[] bs = thisClient.Receive( ref IPEndPointNull);
                    string msg = System.Text.Encoding.UTF8.GetString(bs,0,bs.Length);

                    if ( OnRecieve != null )
                        OnRecieve(msg);
                }
                catch(Exception e)
                {
                    //Some Error Message
                    if(OnError!=null)
                        OnError("Error Recieving: " + e.Message);
                    done = true;
                    isRunning = false;

                }
            }
        }

        public void Stop()
        {
           
            if ( !isRunning ) return ;
           
            //Say your goodbyes to all the members of the group...
            done = true;
            isRunning = false;

            byte[] bs = System.Text.Encoding.UTF8.GetBytes( Dns.GetHostByName(
Dns.GetHostName() ).AddressList[0].ToString() + " has left." ) ;
            thisClient.Send(bs,(int) bs.Length, RemoteEndPoint);
                       
#if CF
            Thread.Sleep(300);
#endif

            if( OnDisconnect!=null)
                OnDisconnect( string.Empty );

           
            try
            {
                thisClient.DropMulticastGroup(IPAddress.Parse(mygroupAddress));
                thisClient.Close();
            }
            catch(Exception e)
            {
                if(OnError!=null)
                    OnError("Error Closing: " + e.Message);
            }
        }

        public void Send( string Message)
        {
            if ( !isRunning ) return ;

            try
            {
                byte[] bs = System.Text.Encoding.UTF8.GetBytes(Message);
                thisClient.Send(bs,(int) bs.Length, RemoteEndPoint);
            }
            catch(Exception e)
            {   
                //Some Error Message
                if(OnError!=null)
                    OnError("Error Sending: " + e.Message);
                done = true;
                isRunning = false;
            }
        }

       
        public event OnRecieveDataEventHandler OnRecieve;
        public event OnConnectEventHandler OnConnect;
        public event OnDisconnectEventHandler OnDisconnect;
        public event OnErrorEventHandler OnError;
    }
}