//____________________________________________________________________________
        //
        private void PushMessageArray(OutgoingMessageHolder theOutgoingMessageHolder)
        {
            SocketAsyncEventArgs connectEventArgs;

            //Get a SocketAsyncEventArgs object to connect with.

            //Get it from the pool if there is more than one.
            connectEventArgs = this.poolOfConnectEventArgs.Pop();
            //or make a new one.
            if (connectEventArgs == null)
            {
                connectEventArgs = CreateNewSaeaForConnect(poolOfConnectEventArgs);
            }

            ConnectOpUserToken theConnectingToken = (ConnectOpUserToken)connectEventArgs.UserToken;

            if (Program.watchProgramFlow == true)   //for testing
            {
                Program.testWriter.WriteLine("PushMessageArray, connect id = " + theConnectingToken.TokenId);
            }

            theConnectingToken.outgoingMessageHolder = theOutgoingMessageHolder;

            StartConnect(connectEventArgs);
            //Loop back to get message(s) for next connection.
            CheckStack();
        }
        //____________________________________________________________________________
        //
        internal void GetMessages(Stack <OutgoingMessageHolder> theStackOfOutgoingMessages)
        {
            if (Program.watchProgramFlow == true)   //for testing
            {
                Program.testWriter.WriteLine("GetMessages");
            }
            this.stackOfOutgoingMessages = new BlockingStack <OutgoingMessageHolder>(theStackOfOutgoingMessages);

            //In this case the stack contains only one OutgoingMessageHolder which will be reused
            //by the CheckStack method.
            if (Program.runLongTest == true)
            {
                this.outgoingMessageHolderForLongTest = this.stackOfOutgoingMessages.Pop();
            }

            this.startTime = DateTime.Now.Ticks;
            Thread t = new Thread(CheckStack);

            t.Start();
        }
        internal Stack <OutgoingMessageHolder> CreateMessageStack()
        {
            //We start by building all the messages
            //that we will send, and putting them in a jagged
            //array. This is just something we'll do for testing.
            //We don't want the message building to be a bottleneck
            //in the testing of our network app.
            //The top level size of the jagged array is equal
            //to the number of clients that we'll connect to the
            //server from this machine. The second level size
            //is equal to the number of messages that we'll send
            //from the client.
            string                messageToSend     = "";
            string                tempMessageToSend = "";
            StringBuilder         theStringBuilder  = new StringBuilder();
            OutgoingMessageHolder outgoingMessageHolder;

            Console.WriteLine();
            Console.WriteLine("Creating arrays of messages to send to server from each client.");
            Console.WriteLine();
            string lastMessage         = "";
            string myTempMessageToSend = "";

            //If you are running a test that is so long that it cannot be held
            //in memory, then you can just send the same array of messages over
            //and over, instead of having a separate array for each connection.
            if (Program.runLongTest == true)
            {
                this.arrayOfMessages = new string[configHandler.numberOfSentMessagesPerConnection];

                for (int i = 0; i < configHandler.numberOfSentMessagesPerConnection; i++)
                {
                    myTempMessageToSend     = "M" + (i + 1).ToString() + "-C0000";
                    this.arrayOfMessages[i] = myTempMessageToSend;
                }
                outgoingMessageHolder = new OutgoingMessageHolder(this.arrayOfMessages);
                //When Program.runLongTest == true there will be only one item in the stack
                this.stackOfOutgoingMessages.Push(outgoingMessageHolder);
            }
            else
            {
                Int64 count = Convert.ToInt64(configHandler.numberOfSentMessagesPerConnection * configHandler.totalNumberOfClientConnectionsToRun);
                if (count > 1000000)
                {
                    Console.WriteLine("runLongTest == false. So, all messages are put in memory first.\r\nIf you have a lot of messages to send, you'll use a lot of memory.");
                    Console.WriteLine("If you are running a test that is so long that it cannot\r\nbe held in memory, make Program.runLongTest = true.");
                }


                bool needToGetLastMessage = true;

                for (Int32 counter = this.configHandler.totalNumberOfClientConnectionsToRun; counter > 0; counter--)
                {
                    this.arrayOfMessages = new string[configHandler.numberOfSentMessagesPerConnection];

                    for (Int32 i = 0; i < configHandler.numberOfSentMessagesPerConnection; i++)
                    {
                        theStringBuilder.Length = 0; //clear the StringBuilder
                        theStringBuilder.Append("M");
                        theStringBuilder.Append((i + 1).ToString());
                        theStringBuilder.Append("-C");

                        theStringBuilder.Append(counter.ToString());
                        tempMessageToSend = theStringBuilder.ToString();

                        //You can change messageType to 1, if you want to generate
                        //just a few messages for each client, and where each message
                        //will be different.
                        Int32 messageType = 0;
                        if (messageType == 0)
                        {
                            messageToSend = tempMessageToSend;
                        }
                        else
                        {
                            //Let's change the messages up by just appending the same message
                            //once for each loop. So, notice that this will make them longer
                            //and longer. So, you might want to do something else, if you need
                            //to test sending a lot of messages from one client.
                            for (int j = 0; j < i + 1; j++)
                            {
                                theStringBuilder.Append(tempMessageToSend);
                            }
                            messageToSend = theStringBuilder.ToString();
                        }

                        this.arrayOfMessages[i] = messageToSend;
                    }
                    outgoingMessageHolder = new OutgoingMessageHolder(this.arrayOfMessages);
                    this.stackOfOutgoingMessages.Push(outgoingMessageHolder);
                    if (needToGetLastMessage == true)
                    {
                        lastMessage          = messageToSend;
                        needToGetLastMessage = false;
                    }
                }
            }
            Console.WriteLine();
            Console.WriteLine("Arrays of messages built and put in stack.");
            if (Program.runLongTest == true)
            {
                Console.WriteLine("runLongTest == true. So, the same array of messages will be sent over and over, to conserve memory.");
                Console.WriteLine("First message starts on the next line:");
                Console.WriteLine(this.stackOfOutgoingMessages.Peek().arrayOfMessages[0]);
                Console.WriteLine("\r\nLast message starts on the next line:");
                Console.WriteLine(myTempMessageToSend);
            }
            else
            {
                Console.WriteLine("First message of first client starts on the next line:");
                Console.WriteLine(this.stackOfOutgoingMessages.Peek().arrayOfMessages[0]);
                Console.WriteLine("\r\nLast message of last client starts on the next line:");
                Console.WriteLine(lastMessage);
            }

            NumberFormatInfo numFormat = new CultureInfo(CultureInfo.CurrentCulture.ToString(), false).NumberFormat;

            numFormat.NumberDecimalDigits = 0;

            Console.WriteLine("\r\nNumber of connections to be started in this test = " + configHandler.totalNumberOfClientConnectionsToRun.ToString("n", numFormat));
            Console.WriteLine("Number of messages per connection = " + configHandler.numberOfSentMessagesPerConnection.ToString("n", numFormat));

            long totalMessages = Convert.ToInt64(configHandler.numberOfSentMessagesPerConnection) * Convert.ToInt64(configHandler.totalNumberOfClientConnectionsToRun);

            Console.WriteLine("Total messages to be sent in this test = " + totalMessages.ToString("n", numFormat));
            Console.WriteLine();
            Console.WriteLine("Test is running ...");
            Console.WriteLine();
            return(this.stackOfOutgoingMessages);
        }