High CPU % when using delegate

Question

I'm running the following piece of code which uses a delegate to return an asynchronous Network Stream:

static void Main(string[] args)
{
    NetworkStream myNetworkStream;
    Socket socket;
    IPEndPoint maxPort = new IPEndPoint(IPAddress.Parse("xxx.xxx.xxx.xxx"), xxxx);

    socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.IP);
    socket.Connect(maxPort);

    myNetworkStream = new NetworkStream(socket);

    byte[] buffer = new byte[1024];
    int offset = 0;
    int count = 1024;

    string Command = "LOGIN,,,xxxx\n";
    ASCIIEncoding encoder = new ASCIIEncoding();

    myNetworkStream.BeginRead(buffer, offset, count, new AsyncCallback(OnBeginRead), myNetworkStream);
    myNetworkStream.Write(encoder.GetBytes(Command), 0, encoder.GetByteCount(Command));

    while (true) { }
}

public static void OnBeginRead(IAsyncResult ar)
{
    NetworkStream ns = (NetworkStream)ar.AsyncState;
    int bufferSize = 1024;
    byte[] received = new byte[bufferSize];

    ns.EndRead(ar);

    int read;

    while (true)
    {
        if (ns.DataAvailable)
        {
            string result = String.Empty;

            read = ns.Read(received, 0, bufferSize);
            result += Encoding.ASCII.GetString(received);
            received = new byte[bufferSize];

            result = result.Replace(" ", "");
            result = result.Replace("\0", "");
            result = result.Replace("\r\n", ",");

            Console.WriteLine(result);
        }
    }
}

It works, but my CPU usage is through the roof (50% on an Intel Core i3), so obviously I'm doing it wrong, but how so?

Thanks

Answer 1

Perhaps replace the inefficiency of spinning the processor at the bottom of your main method from

while (true) { }  

to

Console.ReadLine();

Incidentally Lucero is spot on. You're moving into an infinte loop (in OnBeginRead) with the thread that calls the callback method. This feels wrong. Callbacks should be dealt with asap to let the calling thread carry on processing. Normally you would extract the data in the callback and post a signal to your own thread to process the rest. Perhaps a TPL thread will help here.

Answer 2

You're only reading the very first bytes asynchronously, afterwards you end up in an infinite loop with sync read operations in your OnBeginRead method (which is a confusing name BTW). At the same time, those first bytes are discarded in your current code.

You need to process the data after EndRead (which is a function returning how many bytes were read into the buffer in this async operation), and then start another async read with BeginRead and return (there is no looping in the async code!).

Edited to add a sample showing how async reading would work:

internal class StreamHelper {
    private readonly NetworkStream stream;
    private readonly byte[] buffer = new byte[1024];

    public StreamHelper(Socket socket) {
        stream = new NetworkStream(socket);
    }

    public NetworkStream Stream {
        get {
            return stream;
        }
    }

    public byte[] Buffer {
        get {
            return buffer;
        }
    }
}

private static void Main(string[] args) {
    IPEndPoint maxPort = new IPEndPoint(IPAddress.Parse("xxx.xxx.xxx.xxx"), 100);

    Socket socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.IP);
    socket.Connect(maxPort);

    StreamHelper helper = new StreamHelper(socket);
    helper.Stream.BeginRead(helper.Buffer, 0, helper.Buffer.Length, StreamReadCallback, helper);

    string Command = "LOGIN,,,xxxx\n";
    byte[] bytes = Encoding.ASCII.GetBytes(Command);
    // note: the write isn't async, but should maybe be converted as well
    helper.Stream.Write(bytes, 0, bytes.Length);

    Console.ReadLine(); // wait for a return key press
}

private static void StreamReadCallback(IAsyncResult ar) {
    StreamHelper helper = (StreamHelper)ar.AsyncState;
    // note: EndRead will throw an exception if something went wrong - you should deal with that
    int bytesRead = helper.Stream.EndRead(ar);
    if (bytesRead > 0) {
        string charsRead = Encoding.ASCII.GetString(helper.Buffer, 0, bytesRead);
        Console.Write(charsRead);
        helper.Stream.BeginRead(helper.Buffer, 0, helper.Buffer.Length, StreamReadCallback, helper);
    }
}

Answer 3

You are looping continuously on the main thread:

while (true) { }

This causes the CPU core of that thread to be at full capacity at all times. Try to sleep in order to prevent the thread from taking up CPU time unnecessarily:

while (true) { Thread.Sleep(5000); }