<p>The title basically spells it out. What interfaces have you written that makes you proud and you use a lot. I guess the guys that wrote <code>IEnumerable&lt;T&gt;</code> and not least <code>IQueryable&lt;T&gt;</code> had a good feeling after creating those.</p>

I guess the guys that wrote IEnumerable … had a good feeling after creating [it].
I'm not so sure.
```
IEnumerable
```
was quite a failure, as interfaces go. This is evident from the fact that
```
IEnumerable<T>
```
, its generic counterpart, actually offers a completely
different
interface. (Well, “different” isn't a good word; basically, it adds disposability and de-emphasizes the completely useless
```
Reset
```
method; however, this method is of course still present.)
Additionally, similar languages that have similar constructs (Java comes to mind) have a much better, more extensible construct to fulfill the same needs (and more). For example, Java's iterators can be extended to be bidirectional or to allow modifying access (whereas
```
IEnumerable
```
is always read-only).
EDIT:
Since there's so much controversy in the comments, let me clarify. I'm not saying that
```
IEnumerable
```
(or
```
IEnumerator
```
) are
bad
interfaces. They're adequate. However, they could have been made better. If nothing else, then at least the
```
Reset
```
method seems like clutter.
Terjet said that he “use[s] it all the time” – which is precisely my point!
```
IEnumerable
```
is a pivotal interface of the whole .NET framework. It's ubiquitous. There'd be no .NET without it. Is it therefore too much to ask for a
perfect
interface?
“Adequate” is just another word for failure.