String Isolation Class As a lone developer I don't really have anyone to peer review my work in-house so I was hoping someone could take a look at this class and tell me in what ways I could improve it.

Essentially what this class does is receive a string from a socket that could possibly have multiple messages in it and isolates these messages based on the message terminator. In the isolate message method, it acquires the number of terminators with split and then loops through and adds the substring to the list of messages. Afterwards it removes that substring from the data string.

Off the top of my head the first opts I spot are using an array based off the terminator count instead of a list and making the terminator string array global so it's not making a new array each time.

internal class MessageHandler
{
    const string m_MessageTerminator = "&lt;|&gt;";
    int m_TerminatorLength = m_MessageTerminator.ToArray().Length;

    internal void ProcessStream(SocketState state)
    {
        ///Extract individual messages from socket message queue.
        ProcessMessages(IsolateMessages(state.MessageQueue.ToString()));

        //Find the last index of the message terminator and remove the substring from the string builder.
        //We do not want to clear the string builder because it could have partial messages inside.
        int lastTerminatorIndex = state.MessageQueue.ToString().LastIndexOf(m_MessageTerminator);
        state.MessageQueue.Remove
            (0, lastTerminatorIndex + m_TerminatorLength);
    }

    internal string[] IsolateMessages(string data)
    { 
        List&lt;string&gt; messages = new List&lt;string&gt;();
        string[] terminators = new string[] { m_MessageTerminator };
        int terminatorCount = data.Split(terminators, StringSplitOptions.None).Length -1;

        for(int i = 0; i &lt; terminatorCount; i++)
        {
            //Find The First Instance Of Message Termination
            int terminatorIndex = data.IndexOf(m_MessageTerminator);

            //Extract The Message Based On Terminator's Index
            //Then Remove The Terminator From The Message.
            messages.Add(data.Substring
                (0, terminatorIndex + m_TerminatorLength)
                    .Remove(terminatorIndex, m_TerminatorLength));

            //Remove The Message We Just Extracted From Overall Data Set
            data = data.Remove(0, terminatorIndex + m_TerminatorLength);
        }

        if (messages.Count &gt; 0)
            return messages.ToArray();
        else
            return null;
    }

    internal void ProcessMessages(string[] messages)
    {
        if (messages == null)
            return;

        for(int i = 0; i &lt; messages.Length; i++)
        {
            Console.WriteLine(messages[i]);
        }
    }
}
IsolateMessages()
You are creating a lot of strings here. Each time you call Substring(), or .Remove() on a string you are creating a new string. In addition the readability of

messages.Add(data.Substring
    (0, terminatorIndex + m_TerminatorLength)
        .Remove(terminatorIndex, m_TerminatorLength));


is very very bad.

By returning an IEnumerable&lt;string&gt; instead of string[] the execution of that method can be deffered by using yield.
By using the overloaded IndexOf(int, int) you could omit the terminatorCount and replace the for loop by a while loop.

Applying these two points would lead to this beautyful code
internal IEnumerable&lt;string&gt; IsolateMessages(string data)
{
    if (string.IsNullOrWhiteSpace(data)) { yield break; }

    var currentIndex = 0;
    var terminatorIndex = -1;

    while ((terminatorIndex = data.IndexOf(m_MessageTerminator, currentIndex)) &gt; 0)
    {
        var messageLength = terminatorIndex - currentIndex;

        yield return data.Substring(currentIndex, messageLength);

        currentIndex = terminatorIndex + m_TerminatorLength;
    }
}  

the only difference to your code is that if there is no message or the passed string data is empty my message isn't returning null so you could change the ProcessMessages() like
internal void ProcessMessages(IEnumerable&lt;string&gt; messages)
{
    foreach(var message in messages)
    {
        Console.WriteLine(message);
    }
}