Why CancellationTokenRegistration exists and why does it implement IDisposable

Question

I\'ve been seeing code that uses Cancellation.Register with a using clause on the CancellationTokenRegistration result:

Answer 1

why does it even implements IDisposable? what resources does it have to release?

IDisposable is often used for things completely unrelated to releasing resources; it's a convenient way to ensure something will be done at the end of a using block, even if an exception occurs. Some people (not me) argue that doing this is an abuse of the Dispose pattern.

In the case of CancellationToken.Register, the "something" is the unregistration of the callback.

Note that in the code you posted in your question, the use of a using block on the CancellationTokenRegistration is almost certainly a mistake: since wc.DownloadStringAsync returns immediately, the callback will be unregistered immediately, before the operation has a chance to be cancelled, so wc.CancelAsync will never be called, even if the CancellationToken is signaled. It would make sense if the call to wc.DownloadStringAsync was awaited, because in that case the end of the using block wouldn't be reached before the completion of wc.DownloadStringAsync. (EDIT: not true anymore since the question was edited)

What happens if you don't Dispose of it? what do you leak?

In this case, what happens is that the callback is not unregistered. It probably doesn't really matter, because it's only referenced by the cancellation token, and since CancellationToken is a value type that is typically stored only on the stack, the reference will disappear when it goes out of scope. So it won't leak anything in most cases, but it might if you store the CancellationToken somewhere on the heap. EDIT: actually, that's not correct; see Noseratio's answer for an explanation