NinjaScript Best Practices

1
// Best practice
2
protected override void OnStateChange()
3
{
4
   // these are the values that show up as default on the UI
5
   if (State == State.SetDefaults)
6
   {
7
     Calculate = Calculate.OnPriceChange;
8
     IsOverlay = false;
9
10
     Period = 50;
11
12
     AddPlot(Brushes.Blue, "Plot Value");
13
     AddLine(Brushes.Gray, 100, "Threshold");
14
   }

1
// Best practice
2
[Browsable(false)] // prevents from showing up on the UI property grid
3
public int Communicator { get; set; 

1
// Best practice
2
[NinjaScriptProperty] // can now call **MyIndicator**(20) from another object
3
public int Period { get; set; }

1
// Best practice
2
[XmlIgnore] // removes from serialization
3
public Brush DownBrush
4
{ get; set; }

1
// Practice to avoid
2
protected override void OnStateChange()
3
{
4
   if (State == State.SetDefaults)
5
   {
6
       // logic could take longer than desired as the list of indicator names is populated
7
       for (int i = 0; i <= array.length; i++)
8
           DoWork(i);
9
10
       // possible null reference exception since **TickSize** is not set yet
11
       Period = 5 * TickSize;
12
   }

1
// Best practice
2
protected override void OnStateChange()
3
{
4
   // Complex operations should be delayed to >= State.Configure
5
   if (State == State.Configure)
6
   {
7
       for (int i = 0; i <= array.length; i++)
8
           DoWork(i);
9
   }
10
11
   // information related to market data is not available until at least State.DataLoaded
12
   else if (State == State.DataLoaded)
13
   {
14
       Period = 5 * TickSize;
15
   }
16
}

1
// Best practice
2
// value is always 5, it can be made constant and declared at the class level
3
private const int multiplier = 5;
4
5
// these values can change, may be better to delay setting until State.Configure
6
private int counter;
7
private List<int> myList;
8
9
protected override void OnStateChange()
10
{
11
   if (State == State.Configure)
12
   {
13
       counter = 0;
14
       myList = new List<int>();
15
   }  

1
// Best practice
2
// examples of fields which need to be reset
3
private double myDouble;
4
private bool myBool;
5
private DateTime myDateTime;
6
private Order myOrderObject;
7
private Brush myBrushObject;
8
private Array myIntArray;
9
private List<object> myList;
10
private SMA mySMAIndicator;
11
private Series<double> mySeries;
12
13
protected override void OnStateChange()
14
{
15
   if (State == State.SetDefaults)
16
   {
17
       // disabled to take advantage of performance gains
18
       // However any strategy state that would be mutable after State.SetDefaults needed to be reset for the next run.
19
       IsInstantiatedOnEachOptimizationIteration = false;
20
   }
21
   else if (State == State.Configure)
22
   {
23
       // Since these values are not dependent on bars, they can be reset as early as State.Configure
24
       myDouble = double.MinValue;
25
       myBool = false;
26
       myDateTime = DateTime.MinValue;
27
       myOrderObject = null;
28
       myBrushObject = null;
29
30
       if (myIntArray != null)
31
           Array.Clear(myIntArray, 0, myIntArray.Length);
32
       else
33
           myIntArray = new int[20];
34
35
       if (myList != null)
36
           myList.Clear();
37
       else
38
           myList = new List<object>();
39
   }
40
41
   else if (State == State.DataLoaded)
42
   {
43
       // Since these values do are dependent on bars, they should only reset during State.DataLoaded
44
       mySMAIndicator = SMA(14);
45
       mySeries = new Series<double>(this);
46
   }

1
// Best practice
2
protected override void OnStateChange()
3
{
4
   if (State == State.DataLoaded)
5
   {
6
       // these objects and their related members are not available until State.DataLoaded
7
       Print(Bars.Count);
8
       Print(Instrument.FullName);
9
       Print(BarsPeriod.BarsPeriodType);
10
       Print(TradingHours.TimeZon;
11
       Print(Input);
12
   }
13
}

1
// Best practice
2
// these resources depend on bars, wait until State.DataLoaded to instantiated
3
private EMA myEMA;
4
private Series<double> mySeries;
5
private SessionIterator mySessionIterator;
6
7
protected override void OnStateChange()
8
{  
9
   if (State == State.DataLoaded)
10
   {
11
       myEMA = EMA(20);
12
       mySeries = new Series<double>(this);
13
       mySessionIterator = new SessionIterator(Bars);
14
   }

1
// Best practice
2
protected override void OnStateChange()
3
{
4
   // wait until at least State.Historical
5
   if (State == State.Historical)
6
   {
7
       // and double check UI object is not null before accessing
8
       if (ChartControl != null)
9
       {
10
           Print(ChartControl.Properties.ChartBackground);
11
       }
12
   }
13
}

1
// Best practice
2
private Order entryOrder = null;
3
4
protected override void OnBarUpdate()
5
{
6
   if (entryOrder == null && Close[0] > Open[0])
7
       entryOrder = EnterLongLimit("myEntryOrder", Low[0]);
8
}
9
10
protected override void OnOrderUpdate(Order order, double limitPrice, double stopPrice, int quantity, int filled, double averageFillPrice, OrderState orderState, DateTime time, ErrorCode error, string nativeError)
11
{
12
   // One time only, as we transition from historical
13
   // Convert any old historical order object references to the live order submitted to the real-time account
14
   if (entryOrder != null && entryOrder.IsBacktestOrder && State == State.Realtime)
15
       entryOrder = GetRealtimeOrder(entryOrder);
16
17
   // Null entryOrder if filled or cancelled. We do not use the Order objects after the order is filled, so we can null it here
18
   if (entryOrder != null && entryOrder == order)
19
   {
20
       if (order.OrderState == OrderState.Cancelled && order.Filled == 0)
21
           entryOrder = null;
22
       if (order.OrderState == OrderState.Filled)
23
           entryOrder = null;
24
   }

1
// Best practice
2
protected override void OnStateChange()
3
{
4
   if (State == State.Configure)
5
   {
6
       myObject = new object();
7
       // set a flag to indicator object has been configured
8
       configured = true;
9
   }
10
11
   else if (State == State.Terminated)
12
   {
13
       // only dispose of object if it has been configured
14
       if (configured)
15
       {
16
           myObject.Dispose();
17
       }
18
   }
19
}

1
// Best practice
2
3
// checking to ensure chart control is available in all situations
4
// will help to ensure this logic below does not generate errors at a later time
5
if(ChartControl != null)
6
{
7
   myBackgroundBrush = ChartControl.Properties.ChartBackground;
8
}

1
// Best practice
2
3
protected override void OnStateChange()
4
{
5
   // this logic runs asynchronously to other events
6
   if (State == State.Terminated)
7
   {
8
       myObject = null;
9
   }
10
}
11
protected override void OnRender(ChartControl chartControl, ChartScale chartScale)
12
{
13
   if (myObject == null)
14
       return;
15
16
   // for safety, always check for null references before attempting to access an object
17
   // even if you have once checked for null references earlier run-time
18
   if (myObject != null)
19
       myObject.DoSomething();
20
}

1
// Best practice
2
if (State == State.Historical)
3
{
4
   if (ChartControl.Properties.EquidistantBarSpacing == true)
5
   {
6
       Draw.TextFixed(this, "error", "This indicator works best with Equidistant BarSpacing set to false.", TextPosition.BottomRight);
7
   }
8
}

1
// Best practice
2
// using a Dispatcher will ensure that the corresponding action executes on the associated thread
3
this.Dispatcher.InvokeAsync(() =>
4
{
5
   UserControlCollection.Add(new System.Windows.Controls.TextBlock
6
   {
7
       Text = "\nAdded by the ChartControl Dispatcher."
8
   });
9
});

1
// Practice to avoid
2
protected override void OnBarUpdate()
3
{
4
   try
5
   {
6
       // encapsulates entire OnBarUpdate logic
7
   }
8
   catch (Exception ex)
9
   {
10
       // attempt to handle all errors in one catch
11
   }
12
}

1
// Best practice
2
// predefined brush
3
BackBrush = Brushes.Blue;
4
5
// if you are using a custom brush to e.g., modify the opacity
6
SolidColorBrush opaqueBlue = new SolidColorBrush(Colors.Blue) {Opacity = .25f};
7
8
// or just using at custom color not available in pre-defined brushes class
9
SolidColorBrush coolGreen = new SolidColorBrush(Color.FromRgb(30, 255, 128));
10
11
// you must freeze these brushes after they are constructed!
12
opaqueBlue.Freeze();
13
coolGreen.Freeze();

1
// Best practice
2
// OnRender is not a market data event; barsAgo pointers are not guaranteed to be in sync
3
protected override void OnRender(ChartControl chartControl, ChartScale chartScale)
4
{
5
   Print(mySMA.GetValueAt(CurrentBar));
6
}
7
8
// same is true for you custom events
9
private void myCustomClickHandler(object sender, MouseButtonEventArgs e)
10
{
11
   Print(Close.GetValueAt(CurrentBar));
12
}

1
// Practice to avoid
2
// This would run without errors if there were ONLY type HorizontalLine on the chart
3
// But you risk a likely 'System.InvalidCastException' when other draw types are in that collection
4
foreach (HorizontalLine hLine in DrawObjects)
5
{
6
}

1
// Best practice
2
// Use the base IDrawingTool type and then cast to the desired type within the for loop
3
foreach (IDrawingTool hLine in DrawObjects)
4
{
5
   // Note: to prevent further errors, your type casting should be done using the "as" keyword
6
   // Opposed to a direct cast:
7
   // HorizontalLine myLine = (HorizontalLine) hLine;
8
9
   HorizontalLine myLine = hLine as HorizontalLine;
10
11
   // This will allow you to ensure the cast actually occurred
12
   if (myLine != null)
13
   {
14
       Print(myLine.StartAnchor.Price);
15
   }

1
// Practice to avoid
2
// each time you call the SMA() return method there is a small performance cost
3
// implied from the time it takes to look up the cached instance
4
if (Close[0] > SMA(20)[0])
5
{
6
   Print(SMA(20)[0]);
7
   EnterLongLimit(SMA(20)[0]);
8
   Draw.Dot(this, Time[0].ToString(), false, 0, SMA(20)[0], Brushes.DarkGreen);

1
// Best practice
2
3
private SMA mySma;
4
5
protected override void OnStateChange()
6
{
7
   // when the indicator begins processing
8
   // save an instance of the SMA indicator with the desired input
9
   if (State == State.Historical)
10
   {
11
       mySma = SMA(20);
12
   }
13
}
14
15
protected override void OnBarUpdate()
16
{
17
   // use the referenced mySMA throughout the lifetime of the script
18
   if (Close[0] > mySma[0])
19
   {
20
       Print(mySma[0]);
21
       EnterLongLimit(mySma[0]);
22
       Draw.Dot(this, Time[0].ToString(), false, 0, mySma[0], Brushes.DarkGreen);
23
   }

1
// Best practice
2
protected override void OnBarUpdate()
3
{
4
   // saving "myDot" creates an additional reference in memory
5
   Dot myDot = Draw.Dot(this, "myDot" + CurrentBar, false, Time[0], Close[0], Brushes.Blue);
6
7
   if (conditionToRemove)
8
   {
9
       // remove draw object will remove the object from the chart
10
       RemoveDrawObject("myDot");
11
12
       // but your local object "myDot" is still stored in memory.
13
       // Explicitly setting to null will ensure object is marked for garbage collection
14
       myDot = null;
15
   }
16
}

1
// Best practice
2
// example of object instantiated which need to be disposed
3
StreamWriter writer = new StreamWriter("some_file.txt");
4
5
// use the object
6
writer.WriteLine("Some text");
7
8
// implements IDisposbile, make sure to call .Dispose() when finished
9
writer.Dispose();
10
11
// or put in "using" statement which implicitly calls .Dispose() when finished
12
using (StreamWriter writer2 = new StreamWriter("some_file.txt"))
13
{
14
   writer2.WriteLine("Some text");
15
}

1
// Best practice
2
3
// get GetPreviousTradingDayEnd() is expensive to look up
4
// but value only needs to be looked up once a day -> only calculate on first bar of session
5
if (Bar.IsFirstBarOfSession)
6
{
7
   TradingHours.GetPreviousTradingDayEnd(Time[0]);
8
}

1
// Best practice
2
// dedicated logic to cache the prior sum on each tick of bar
3
// While it is a good practice, this can cause problems for bar types which may remove last bar (see below)
4
if (IsFirstTickOfBar)
5
   priorSum = sum;
6
7
sum = priorSum + Input[0] - (CurrentBar >= Period ? Input[Period] : 0);
8
Value[0] = sum / (CurrentBar < Period ? CurrentBar + 1 : Period);

1
// Best practice
2
 // logic below disables first tick of bar caching only on bar types which remove last bar
3
if (BarsArray[0].BarsType.IsRemoveLastBarSupported)
4
{
5
   if (CurrentBar == 0)
6
       Value[0] = Input[0];
7
   else
8
   {
9
       double last = Value[1] * Math.Min(CurrentBar, Period);
10
11
       if (CurrentBar >= Period)
12
           Value[0] = (last + Input[0] - Input[Period]) / Math.Min(CurrentBar, Period);
13
       else
14
           Value[0] = ((last + Input[0]) / (Math.Min(CurrentBar, Period) + 1));
15
   }

1
// Practice to avoid
2
protected override void OnRender(ChartControl chartControl, ChartScale chartScale)
3
{
4
   // continually recalling the same value methods is unnecessary in this situation
5
   double myValue = Bars.GetClose(CurrentBar) + Bars.GetOpen(CurrentBar);
6
7
   // render myValue
8
}

1
// Best practice
2
private double myValue;
3
4
protected override void OnBarUpdate()
5
{
6
   // myValue only needs to update when OnBarUpdate() is called
7
   // and then can be passed to OnRender() for chart rendering purposes
8
   myValue = Close[0] + Open[0];
9
}
10
11
protected override void OnRender(ChartControl chartControl, ChartScale chartScale)
12
{
13
   // if needed, you can always check that myValue has actually been set
14
   if (myValue > double.MinValue)
15
   {
16
       // render myValue
17
   }
18
}

1
// Best practice
2
protected override void OnRender(ChartControl chartControl, ChartScale chartScale)
3
{
4
   // restricting this loop to only the ChartBars.From/ToIndex limits the loop to only what is visible on the chart
5
   for (int barIndex = ChartBars.FromIndex; barIndex <= ChartBars.ToIndex; barIndex++)
6
   {
7
       Print(ChartControl.GetSlotIndexByX(barIndex));
8
   }
9
}

1
// Practice to avoid
2
protected override void OnBarUpdate()
3
{
4
   // this would draw a dot on every bar on the chart
5
   // each instance would need to call its own OnRender() method
6
   // not a very efficient use a draw method
7
   Draw.Dot(this, "everyDot" + CurrentBar, false, 0, Close[0], Brushes.Blue);
8
}   

1
// Best practice
2
protected override void OnRender(ChartControl chartControl, ChartScale chartScale)
3
{
4
   // achieves the same effect of drawing a dot on every bar
5
   // but only needs to call your object's OnRender()
6
   for (int index = ChartBars.FromIndex; index <= ChartBars.ToIndex; index++)
7
   {
8
       float price = chartScale.GetYByValue(Close.GetValueAt(index));
9
       float bar = chartControl.GetXByBarIndex(ChartBars, index);
10
       float radius = (float) chartControl.BarWidth;
11
12
       SharpDX.Direct2D1.Ellipse dot = new SharpDX.Direct2D1.Ellipse(new SharpDX.Vector2(bar, price), radius, radius);
13
14
       using (SharpDX.Direct2D1.SolidColorBrush brush = new SharpDX.Direct2D1.SolidColorBrush(RenderTarget, SharpDX.Color.Blue))
15
       {
16
           RenderTarget.FillEllipse(dot, brush);
17
       }
18
   }
19
}

1
// Best practice
2
protected override void OnStateChange()
3
{
4
   if (State == State.Historical)
5
   {
6
       // subscribe to chart panel mouse down event
7
       if (ChartPanel != null) ChartPanel.MouseDown += DoUserClickedChartPanelEvent;
8
9
       // subscribe to a custom UI element mouse down event
10
       if (myWPFControl != null) myWPFControl.MouseDown += DoCustomWPFControlClickEvent;
11
   }
12
13
   else if (State == State.Terminated)
14
   {
15
       // remember to unsubscribe when finished
16
       if (ChartPanel != null) ChartPanel.MouseDown -= DoUserClickedChartPanelEvent;
17
       if (myWPFControl != null) myWPFControl.MouseDown -= DoCustomWPFControlClickEvent;
18
   }
19
}
20
21
private void DoUserClickedChartPanelEvent(object sender, MouseButtonEventArgs e)
22
{  
23
   Print("User clicked on the ChartPanel, executing custom mouse down logic...");
24
}
25
26
private void DoCustomWPFControlClickEvent(object sender, MouseButtonEventArgs e)
27
{
28
   Print("User clicked on my button, executing button logic...");
29
}

1
// Practice to avoid
2
protected override void OnBarUpdate()
3
{
4
   if (IsFirstTickOfBar && State == State.Realtime)
5
   {
6
       Print("Run some logic before:: " + DateTime.Now);
7
       Thread.Sleep(5000); // sleeping the Instrument thread will have adverse effects on elements outside of your script!
8
       Print("Run some logic after: " + DateTime.Now);
9
   }
10
}

1
// Best practice
2
protected override void OnBarUpdate()
3
{
4
   if (IsFirstTickOfBar && State == State.Realtime)
5
   {
6
       // Instead of Thread.Sleep for, create a timer that runs at the desired interval
7
       System.Windows.Forms.Timer timer = new System.Windows.Forms.Timer {Interval = 5000};
8
9
       // queue the "after" logic to run when the timer elapses
10
       timer.Tick += delegate
11
       {
12
           timer.Stop(); // make sure to stop the timer to only fire ones (if desired)
13
           Print("Run some logic after: " + DateTime.Now);
14
           timer.Dispose(); // make sure to dispose of the timer
15
       };
16
17
       Print("Run some logic before: " + DateTime.Now);
18
19
       timer.Start(); // start the timer immediately following the "before" logic
20
   }

1
// Practice to avoid
2
3
// depending on how Value[0] was calculated, it could be off by a degree of floating points
4
// where this logic below would never be true
5
// e.g., 2050.2499999 vs 2050.50
6
if (Value[0] == Close[0])
7
{
8
   // do something
9
}

1
// Best practice
2
3
// you can avoid these precision issues by rewriting the comparison to evaluate within a certain tolerance.
4
if (Math.Abs(Value[0] - Close[0]) < TickSize)
5
{
6
   // do something
7
}
8
9
// You will also see NinjaTrader developed objects use a custom Extension Method
10
// double.ApproxCompare() which Returns an int based on a Epsilon value:
11
if (Close[0].ApproxCompare(Value[0]) == 0)
12
{
13
   // do something
14
}