What should I dispose?

[TheBarChartist]

I noticed in the stock NT8 indicators that DXBrushes are disposed within OnRender(). So I've been doing that in my custom indicators. But is there a way for me to know what I should be disposing without comparing my work to the stock indicators? Is there a list somewhere?

I'm one of those brute force type guys who can make happen what I need to make happen but does not have a programming background.

Thanks for your help. I think NT8 looks great and I'm close to being able to take it for a spin in the live market.

[NinjaTrader_MichaelM]

Hello TheBarChartist,

Thank you for writing in. You should dispose of items when they are no longer needed. If a class implements the IDisposable interface, you should always call the Dispose() method once you have finished using this resource. To ensure that the Dispose() method will be called even if an exception is thrown, you can wrap it in a using statement:

using(var redBrush = new SolidBrush(Color.Red)
{
    g.DrawString(valueText, Font, redBrush);
}

Please let me know if I may be of further assistance.

[overflowing]

Since I'll often want to create a resource such as a brush and use it multiple times and only dispose of it when closing the indicator, where is the proper place to create and dispose of a brush?

SharpDX.Direct2D1.Brush brushDown = BarDownBrush.ToDxBrush(RenderTarget);

Should this be done in OnStateChange()?

State == State.SetDefaults
and
State == State.Terminated

[NinjaTrader_PatrickH]

Hello overflowing,

You would create the brush when needed. And you could remove it it the Terminated State if you prefer. Essentially, add it when you need it, remove it when you no longer need it.

[overflowing]

I notice in the VolumeZones sample indicator the DX brush is instantiated and disposed of inside OnRender(), e.g.:

protected override void OnRender(ChartControl chartControl, ChartScale chartScale)
{
  SharpDX.Direct2D1.Brush brushDown = BarDownBrush.ToDxBrush(RenderTarget);
  ...
  brushDown.Dispose();
}

Surely this isn't efficient if OnRender is called many times? Just seems like it makes more sense to construct and dispose of the brushes outside of OnRender(). Unless there is some reason not to?

[overflowing]

Or are brushes so lightweight that it doesn't matter?

[overflowing]

The reading I've done seems to lean in the direction of not caching drawing objects basically because they are cheap to create and there are limited number of GDI resources available. Seems like the best practice may be to either use system pens and brushes (e.g. Brushes.Red) or use a series of using statements inside the OnRender() method.

Only if you run into a performance issue (generally unlikely) should you consider refactoring to caching drawing objects.


See:

http://stackoverflow.com/questions/8253398/what-is-better-approach-to-dispose-brush-in-user-control

"Creating and destroying drawing objects like pens and brushes is very cheap, takes about a microsecond."
-Hans Passant

And:

http://stackoverflow.com/questions/22814259/best-strategy-for-gdi-object-lifetime

"Caching System.Drawing objects is a mistake. They are very cheap to create, very expensive to keep around. They are allocated on a special heap that all processes on a desktop need to share. The heap size is limited to 65535 objects. Creating objects like a brush or a pen takes roughly a microsecond, miniscule compared to the cost of the operation you perform with them. The only drawing object that is expensive is a Font."
-Hans Passant

And:

http://stackoverflow.com/questions/3532914/should-i-create-new-pens-brushes-per-paint-request-or-keep-them-throughout-the-a

[NinjaTrader_PatrickH]

overflowing,

Thank you for the additional information.