What's the right way to Dispose() a channel?

In the current Indigo bits, there are three things you can do to get rid of a channel object when you're done with it:

channel.Close()
channel.Abort()
channel.Dispose()

All the 'communications objects' in Indigo (channels, factories, listeners, etc) share a common Open/Close state machine - in that model, Close() means "do a clean shutdown" (which for some cases like reliable channels may involve sending and receiving additional infrastructure messages), while Abort() means "clean up your resources and quit right away."

The interesting one is Dispose(); its the one that provides support for this idiom:

using (MyProxy proxy = new MyProxy())
{
proxy.SendMessage();
}

The .NET Frameworks guidelines say that Dispose() should be the same as Close(); and if that were the case, the code above would be correct. However, there are a couple problems with that model:

problem #1: Since Close() may incur message exchanges, it can block for a while. Blocking shutdown, particularly if you're on the finalizer thread, is considered a 'bad thing'.

problem #2: if you're sending a series of messages in a session, and you fail to send all the messages you intended to send - you'd like the other side to know about it. Consider this case:

using (MySessionfulProxy proxy = new MySessionfulProxy())
{
proxy.SendFirstMessage();
// some other code throws an exception here
proxy.SendLastMessage();
}

When the exception gets thrown, Dispose() calls Close(), which will do a clean shutdown of the session - as far as the other side knows, everything was sent just fine - when in fact it failed to receive the last message.

Because of these issues, we chose to make Dispose() the same as Abort(). The correct way to use a channel in the current bits is:

using (MyProxy proxy = new MyProxy())
{
proxy.SendMessage();
proxy.Close();
}

If everything works correctly, we call Close() and get a clean shutdown; if an exception gets thrown, then we Abort().

We have gotten some feedback that requiring that explicit Close() call isn't intuitively obvious, and even if you know about the requirement, you may sometimes forget to do it. We're eager to get more feedback on this issue; especially if you have other compelling arguments pro or con. Please, weigh in and let us know what you think! - and if there is some third option even better than the two described above, I'd love to hear about it.

On a side note, another thing we like about the current model is that it is similar to how TransactionScope works; the transaction team is also part of Indigo:

using (TransactionScope tx = new TransactionScope())
{
// do some work here
tx.Complete();
}