To Dispose() or not Dispose(), that is the question.

Here is an application of Dispose techniques to your code snippet:

First, the problem with your code is this: the lack of exception handling. Basically, when disposeable resources are allocated, you need to wrap the rest of the code in try-finally block and dispose them in finally block. Better yet, use syntax candy of using block; you can allocate several instances of resources in a single using block. (Yes, this is just syntax candy: the documentation clearly states that using is functionally precisely equivalent to the try-finally block.) This way, your resources will be disposed even in the case of exception.

Secondly, you need to consider alternative of using of the Form's (and related component model's) disposable pattern. Allocating and disposing of resources is relatively expensive. Ask yourself, do you have any resource which could be re-used in your method DrawRotatedText? (If not, how about another, similar method?)
In fact, your brush variable is redundant, and its Dispose call is a mistake, because you're actually trying to dispose Brushes.Black; and font, attr, and imageFormat are all re-usable. So, you can promote these local variables to the position of your Form's class slots, allocate before showing the form and dispose from withing the Form's method Form.Dispose(Boolean) by overriding this method.

The IDisposable.Dispose is used in one more case: when you need to control some action called at the moment of disposable. The moment of the destructor call is (in regular code not tricking GC) is normally out of your control.

In .NET, the rule of thumb is not writing destructors at all; there are exclusions, of course.

Example: you have some object which you create, call one method of it which takes a second or two then it is not needed anymore; and want to do it on UI thread. You need to make sure the application shows Hourglass cursor while application is busy with this method. There is a little problem here: you do not to forget to set this cursor back; you also don't want to get stuck with the Hourglass cursor is an exception is thrown.

Here is the technique: create object controlling mouse pointer: 1) in constructor, set up hourglass mouse pointer; 2) make it disposable, in Dispose, setup default mouse pointer or a pointer remembered at the moment of the constructor call, then use:

using(WaitCursorIndicator controller = new WaitCursorIndicator(myControl) {
   //do your time-taking action
}

Please look at my Tips/Tricks article for detailed explanation:
Hourglass Mouse Cursor Always Changes Back to its Original Image. How?[^]

On the end of using block, default mouse pointer will be restored, even on exception. There are a lot of similar techniques like that.

Typically, IDisposable is useful if you take benefits of using block or
if you need a chain of dispose action going to the very top level, such as a form. (Criteria listed in previous answer should apply.)

Just for example, yet another use case of Dispose: see this:

Hourglass Mouse Cursor Always Changes Back to its Original Image. How?[^]