Diff comparison for List<string>

I wouldn't want to maintain this code. Unless you have proven that this code is a performance problem, do the simple thing. Yes, the following solution will iterate over the lists 3 times. No, I don't care that it does.

var both = listA.Intersect(listB);
var listAOnly = listA.Except(listB);
var listBOnly = listB.Except(listA);

If you're worried about case insensitivity, pass in a StringComparer.

Firstly, your algorithm fails in the case where listA or listB can have duplicates.

You should generate more test cases and check them against the following code. This code is not as efficient as it can be since it enumerates the list many times over, but should provide you cases for comparison:

public static void ListDiff2(List<string> listA, List<string> listB, bool ignoreCase,  
                                    out List<string> both, out List<string> listAonly, out List<string> listBonly)
    {

        both = listA.Where(a => listB.IndexOf(a) >= 0).ToList();
        listAonly = listA.Where(a => listB.IndexOf(a) == -1).ToList();
        listBonly = listB.Where(a => listA.IndexOf(a) == -1).ToList();
    }

Secondly, your style is over-engineered with a lot of checking for the end of the lists. It is better to loop while you can move either iterator and then consider that if you have an empty list on one side, then all the remaining items end up in "listAonly" or "listBonly" as appropriate.

Note that with your comparisons you could also use switch/case after your string comparison, however the specification doesn't actually guarentee that String.Compare returns -1, 0 or 1, just that it will be less than zero, equal to zero or greater than zero.

I would avoid the use of iterators and instead prefer indexes when all you are doing is moving them next by one.

Applying all those refactorings results in the following:

public static void ListDiff(List<string> listA, List<string> listB, bool ignoreCase,  
                                out List<string> both, out List<string> listAonly, out List<string> listBonly)
{
    both = new List<string>();
    listAonly = new List<string>();
    listBonly = new List<string>();

    List<string> listAsorted = listA.OrderBy(x => x).Distinct().ToList();
    List<string> listBsorted = listB.OrderBy(x => x).Distinct().ToList();

    int listAindex = 0;
    int listBindex = 0;

    int aLength = listAsorted.Count();
    int bLength = listBsorted.Count();

    while (listAindex < aLength && listBindex < bLength)
    {
        int comp = string.Compare(listAsorted[listAindex], listBsorted[listBindex], ignoreCase);

        if (comp < 0)
            {
                listAonly.Add(listAsorted[listAindex]);
                listAindex++;
            }
            else if (comp > 0)
            {
                listBonly.Add(listBsorted[listBindex]);
                listBindex++;
            }
            else
            {
                both.Add(listAsorted[listAindex]);
                listAindex++;
                listBindex++;
            }
    }
    //loop has finished, add any remaining items to list.
    while(listAindex < aLength)
        listAonly.Add(listAsorted[listAindex++]);
    while(listBindex < bLength)
        listBonly.Add(listBsorted[listBindex++]);
}

On in your preferred iterator style, this looks like:

public static void ListDiff(List<string> listA, List<string> listB, bool ignoreCase,  
                                out List<string> both, out List<string> listAonly, out List<string> listBonly)
{
    both = new List<string>();
    listAonly = new List<string>();
    listBonly = new List<string>();

    IEnumerable<string> listAsorted = listA.OrderBy(x => x).Distinct();
    IEnumerable<string> listBsorted = listB.OrderBy(x => x).Distinct();

    int aLength = listAsorted.Count();
    int bLength = listBsorted.Count();

    var listAenumerator = listAsorted.GetEnumerator();
    var listBenumerator = listBsorted.GetEnumerator();

    bool listAcanmove = listAenumerator.MoveNext();
    bool listBcanmove = listBenumerator.MoveNext();

    while (listAcanmove && listBcanmove)
    {
        int comp = string.Compare(listAenumerator.Current, listBenumerator.Current, ignoreCase);

        if (comp < 0)
            {
                listAonly.Add(listAenumerator.Current);
                listAcanmove = listAenumerator.MoveNext();
            }
            else if (comp > 0)
            {
                listBonly.Add(listBenumerator.Current);
                listBcanmove = listBenumerator.MoveNext();
            }
            else
            {
                both.Add(listAenumerator.Current);
                listAcanmove = listAenumerator.MoveNext();
                listBcanmove = listBenumerator.MoveNext();
            }
    }
    //loop has finished, add any remaining items to list.
    while(listAcanmove)
    {
        listAonly.Add(listAenumerator.Current);
        listAcanmove = listAenumerator.MoveNext();
    }

    while(listBcanmove)
    {
        listBonly.Add(listBenumerator.Current);
        listBcanmove = listBenumerator.MoveNext();
    }
}

I have one very specific suggestion, that may or may not be worth a whole answer. Oh well, here goes anyway:

I'm not a fan of using function parameters as outputs. I've worked with languages that allow this before, and I generally find it to be confusing down the road and error-prone. Inevitably what happens is you forget that half of your function parameters are outputs instead of inputs, and when you look over the code that uses your function you'll need a minute to figure out what is actually input and what is output. In other words, I find this general syntax:

output = function( input1, input2 )

Much more clear and less confusing than this:

function( input1, input2, output )

In cases like this where a function has to return multiple values, it's just a simple matter of unpacking the return value. From my quick googling C# doesn't have any simple syntax for unpacking return values, but it is still very straight-forward to do if you return a tuple, which is perfect (https://stackoverflow.com/a/8514859/1921979):

var returned = ListDiff( listA, listB );
var Both = returned.Both;
var listAOnly = returned.listAOnly;
var listBOnly = returned.listBOnly;

Granted, this is more verbose due to the lack of an unpacking operator, but the intent is much more clear. That's a big win in my book (also, you don't necessarily have to unpack everything into its own variable). I suppose others may have different opinions though.

Based on the accepted answer I ended up with this.
It is fast. Faster than my original or Intersect Except.
Even take out the sort time this is faster than my original.

public static void ListDiffHash(List<string> listA, List<string> listB, bool ignoreCase, out List<string> both, out List<string> listAonly, out List<string> listBonly)
{
    both = new List<string>(Math.Min(listA.Count, listB.Count)/2);
    listAonly = new List<string>();
    listBonly = new List<string>(listB.Count/2);
    var diffFilter = new HashSet<string>(listA);
    foreach(var item in listB.Distinct())
    {
        if (diffFilter.Contains(item))
        {
            both.Add(item);
            diffFilter.Remove(item);
        }
        else 
        {
            listBonly.Add(item);
        }
    }
    listAonly = diffFilter.ToList();
}