Q:

C# Class is IEnumerable AND an IEnumerator at the same time.  What are the issues with this? 

I have a class called GenericPermutations that is both enumerable and an enumerator.   Its job is to take an ordered list of objects and iterate through each permutation of them in order. 
Example, an integer implemenation of this class could iterate through the following:
GenericPermutations<int> p = new GenericPermutations<int>({ 1, 2, 3 });
p.nextPermutation(); // 123
p.nextPermutation(); // 132
p.nextPermutation(); // 213
// etc. 

So its enumerable in the sense that it contains a 'list' of things you can enumerate over.   It's also an enumerator, because its job involves finding the next permutation. 
THE ISSUE: I am currently trying to integrate IEnumerator and IEnumerable with this class, and it seems to me like it should be both (rather than using a sub class as the IEnumerable).   Thus far I have avoided the issue with trying to get two enumerators from it by passing a new GenericPermutation object in the GetEnumerator method. 
Is this a bad idea?   Anything else I should consider? 

A:

Reduce your confusion (?)  by using the generic versions of IEnumerable and IEnumerator. 
A permutation enumerable is IEnumerable<IEnumerable<T>>.   So you might have something like
IEnumerable<IEnumerable<T>> GetPermutations(IEnumerable<T> sequence)
{
    return new Permuter<T>(sequence);
}

and
public class Permuter<T> : IEnumerable<IEnumerable<T>> { ... }

Furthermore, I've seen more than one case where a single type implemented both IEnumerable<T> and IEnumerator<T>; its GetEnumerator method was simply return this;. 
I think such a type would need to be a struct, though, because if it were a class you'd have all sorts of problems if you called GetEnumerator() a second time before the first enumeration was completed. 
EDIT: Consuming the permuter
var permuter = GetPermutations(sequence);
foreach (var permutation in permuter)
{
    foreach (var item in permutation)
        Console. Write(item + "; ");
    Console. WriteLine();
}

Assuming the input sequence is { 1, 2, 3 }, the output is
1; 2; 3; 
1; 3; 2; 
2; 1; 3; 
2; 3; 1; 
3; 1; 2; 
3; 2; 1; 

EDIT:
Here's a super-inefficient implementation to illustrate the suggestion:
public class Permuter<T> : IEnumerable<IEnumerable<T>>
{
    private readonly IEnumerable<T> _sequence;

    public Permuter(IEnumerable<T> sequence)
    {
        _sequence = sequence;
    }

    public IEnumerator<IEnumerable<T>> GetEnumerator()
    {
        foreach(var item in _sequence)
        {
            var remaining = _sequence. Except(Enumerable. Repeat(item, 1));
            foreach (var permutation in new Permuter<T>(remaining))
                yield return Enumerable. Repeat(item, 1).Concat(permutation);
        }
    }

    IEnumerator IEnumerable. GetEnumerator()
    {
        return GetEnumerator();
    }
}

