Select unique/distinct combination of values from IEnumerable of same type

Question

I have three IEnumerables of the same type (string) and I want to get unique combinations of values from it. Not quite sure how to implement LINQ in here.

The result should be a list of something like this by adding - as separator

a-p-1
b-q-4
b-r-7
c-s-8
c-s-9
d-t-10
e-u-11

Data itself is in unique connection. All projects in one account are unique, and so does all subprojects for a particular project.

Answer 1

You should not be storing related items in separate sequences; that's an antipattern. However, if this happens to be the way that your data is available, you can first combine the items from the sequences using Zip, then use Distinct to get unique values.

var result = accounts.Zip(projects, (a, p) => a + "-" + p)
                     .Zip(subprojects, (a, s) => a + "-" + s)
                     .Distinct()
                     .ToList();

Edit: In the spirit of Servy's answer, here is an extension method for zipping an arbitrary number of sequences:

public static partial class EnumerableExtensions
{
    public static IEnumerable<TResult> Zip<TSource, TResult>(
        this IEnumerable<IEnumerable<TSource>> sequences,
        Func<IEnumerable<TSource>, TResult> resultSelector)
    {
        var enumerators = sequences.Select(sequence => sequence.GetEnumerator()).ToArray();
        while (enumerators.All(enumerator => enumerator.MoveNext()))
            yield return resultSelector(enumerators.Select(enumerator => enumerator.Current));
    }
}

And this is how it would be consumed:

string[][] sequences = { accounts, projects, subprojects };
var results = sequences.Zip(items => string.Join("-", items))
                        .Distinct()
                        .ToList();

Answer 2

While you could use Zip twice to zip three sequences, creating a new three way zip is easy enough and will be easier to work with:

public static IEnumerable<TResult> TriZip<TSource, TResult>(
    this IEnumerable<TSource> first,
    IEnumerable<TSource> second,
    IEnumerable<TSource> third,
    Func<TSource, TSource, TSource, TResult> resultSelector)
{
    using (var firstIterator = first.GetEnumerator())
    using (var secondIterator = second.GetEnumerator())
    using (var thirdIterator = third.GetEnumerator())
        while (firstIterator.MoveNext() &&
            secondIterator.MoveNext() &&
            thirdIterator.MoveNext())
            yield return resultSelector(firstIterator.Current,
                secondIterator.Current,
                thirdIterator.Current);
}

Now your work is pretty much just calling this method, plus a Distinct:

var query = accounts.TriZip(projects, subprojects,
    (account, project, subproject) => 
        new { account, project, subproject })
    .Distinct();