Mal eine Frage an die NT-Spezialisten.

Kann man Microsoft Visual Studio sinnvoll als Editor für NinjaTrader Scripts einsetzen?

 

Mir geht es hauptsächlich um den leistungsfähigeren Editor.

Somit ist Intellisense ein Muss.

Nice to have wäre noch, wenn man aus VS den Compiler aufrufen könnte und dessen Ausgabe in ein VS-Output Window umlenken könnte.

Wenn dies nicht funktioniert, dann müsste ich halt den NinjaScript Editor mit irgendeinen beliebigen Indikator ständig offen haben und diesen zum compilieren verwenden.

 

Was ja recht schön funktioniert, ist das Debuggen von Scripten über Visual Studio. Vollkommen wäre das Ganze halt nun, wenn das Coden auch noch sinnvoll möglich wäre. Hierbei geht es mir hauptsächlich um das Erweitern von bestehendem Code wobei der von NT selbst generierte Code nicht angefasst werden muss.

Ich mache mal kurz:

 

http://www.cashornot...-visual-studio/ (von S. auf deutsch)

 

Es gibt aber auch ein paar englische Sourcen.

 

https://www.google.de/search?aq=1&oq=ninjatrader+visual+st&sourceid=chrome&ie=UTF-8&q=ninjatrader+visual+studio+tutorial

Ich mache mal kurz:...

Danke wh, aber wie gesagt, das Debuggen funktioniert bei mir auch schon.

 

Ich suche eine Beschreibung, wie ich das Intellisense von NT in VS einbinden und im Optimalfall

auch noch mit VS compilieren kann.

Sorry, bin seit NT 6.5 raus.

Müssen nicht die DLLs von NT in VS 2008/2010 geladen werden.

Intellisense ist doch nur ein Autovervollständiger ...

Bin seit den letzen 1 1/2 Jahren ein wenig weg von C# und VS.

 

Hast hier schon mal geschaut: http://www.bigmiketrading.com/ninjatrader-programming/4781-ninjatrader-vs2010-dummies.html

Hast hier schon mal geschaut: http://www.bigmiketr...10-dummies.html

Genau hier bin ich hängengeblieben. Der schreibt:

On VS, File > Open > Project > Documents > Ninja Trader 7 > bin > Custom > NinjaTrader.Custom

That should open a project called NinjaTrader.Custom.

Remove the references for NinjaTrader.Core and WilsonORMapper.

Add references for NinjaTrader.Core and WilsonORMapper by navigating to the NT7 directory in Program Files.

Build Solution (F6).

Bis zu "Remove the references for NinjaTrader.Core and WilsonORMapper." schaff ich das auch noch.

Aber dann sagt er:

"Add references for NinjaTrader.Core and WilsonORMapper by navigating to the NT7 directory in Program Files."

und genau da versteh ich nicht wie das gemeint ist.

Du mußt die Core DLLs irgendwo unter (z.B.) C:\Program Files\NinjaTrader 6.5\bin mappen.

 

Kann ich keine Attachs anhängen?

Hi Wogo,

 

nachdem du die Referenzen zu NinjaTrader.Core und WilsonORMapper entfernt hast kannst du an gleicher Stelle (in VS) neue Referenzen hinzufügen. Hierzu nimmst du einfach die NinjaTrader.Core.dll und WilsonORMapper.DLL aus dem \Ninjatrader\bin\ Verzeichnis.

 

Wichtig - nach dem Built (F6 wars glaub ich) im VS musst du immer auch im Ninjatrader neu compilieren (F5 in einem "dummy"-Script im Ninja-Editor) .

 

grüsse,

askerix

Hi askerix!

 

Vielen Dank!

Das funktioniert jetzt so halbwegs. Soll heissen, es werden mir alle NT-Standardindikatoren angezeigt, aber nicht meine eigenen.

Ich kann diese manuell hinzufügen, dann funktioniert auch bei denen das Intellisense.

 

Ist das so gedacht, dass ich die eigenen Indikatoren/Strategien erst hinzufügen muss, oder mach ich da noch was falsch?

Ist das so gedacht, dass ich die eigenen Indikatoren/Strategien erst hinzufügen muss, oder mach ich da noch was falsch?

Ah ja, hab's gefunden:

Add the Strategies you want to edit by right clicking on the Strategy folder in Solution Explorer, and Add > Existing Item. Navigate to Documents > Ninja Trader 7 > bin > Custom > Strategy and pick a Strategy and use the "Add as link" option in the Add button.

 

Nochmal zusammenfassend:

• In Visual Studio das Projekt "NinjaTrader.Custom" öffnen (z.B. "c:\Users\...\Documents\NinjaTrader 7\bin\Custom\NinjaTrader.Custom.sln" )
  
• NinjaTrader.Core und WilsonORMapper aus "Verweise" entfernen
  
• NinjaTrader.Core.dll und WilsonORMapper.dll (z.B. d:\Programme\NinjaTrader7\bin\NinjaTrader.Core.dll ) hinzufügen (Rechtsklick auf Verweise...)
  

• Mit F6 build und dann in NT ein beliebiges Script compilieren
  
• Die eigenen Indikatoren/Strategien hinzufügen (Indikator=> rechte Maus / Hinzufügen)
  

Schau einer TomNext an. Hier gibt es die Lösung im Netz. Schön ...

Hi,

und cool, daß ihr hier ne deutschsprachige NinjaScript-Ecke aufgemacht habt.

 

Ich nutze auch VS2010, um die Scripte "komfortabel" zu editieren. Ein paar Dinge noch:

 

1. Ich hab mir ein "NTCompileScript" erstellt, das im NinjaEditor immer in nem kleinen Fenster oben im Eck offen ist, um zu compilieren (damit ich nicht aus versehen ein im VS geöffnetes Script compiliere). Sieht so aus:

#region Using declarations
using System;
#endregion
namespace NinjaTrader.Indicator
{
public class CB_NTCompileScript : Indicator
{
protected override void Initialize()
{
// Do nothing
}

protected override void OnBarUpdate()
{
// Do nothing
}
}
}
#region NinjaScript generated code
namespace NinjaTrader.Indicator
{
public partial class Indicator : IndicatorBase
{
private CB_NTCompileScript[] cacheCB_NTCompileScript = null; // <-- Anpassen
private static CB_NTCompileScript checkCB_NTCompileScript = new CB_NTCompileScript(); // <-- Anpassen
public CB_NTCompileScript CB_NTCompileScript() // <-- Anpassen - alle Parameter; kommagetrennt; keine lokalen Variablen
{
return CB_NTCompileScript(Input); // <-- Anpassen - alle Parameter; kommagetrennt; keine lokalen Variablen
}
public CB_NTCompileScript CB_NTCompileScript(Data.IDataSeries input) // <-- Anpassen - alle Parameter; kommagetrennt; keine lokalen Variablen
{
if (cacheCB_NTCompileScript != null) // <-- Anpassen
for (int idx = 0; idx < cacheCB_NTCompileScript.Length; idx++) // <-- Anpassen
 if (cacheCB_NTCompileScript[idx].EqualsInput(input)) // <-- Anpassen - alle Parameter; &&-getrennt; keine lokalen Variablen
 return cacheCB_NTCompileScript[idx]; // <-- Anpassen
lock (checkCB_NTCompileScript) // <-- Anpassen
{

if (cacheCB_NTCompileScript != null) // <-- Anpassen
 for (int idx = 0; idx < cacheCB_NTCompileScript.Length; idx++) // <-- Anpassen
 if (cacheCB_NTCompileScript[idx].EqualsInput(input)) // <-- Anpassen - alle Parameter; &&-getrennt; keine lokalen Variablen
 return cacheCB_NTCompileScript[idx]; // <-- Anpassen
CB_NTCompileScript indicator = new CB_NTCompileScript(); // <-- Anpassen
indicator.BarsRequired = BarsRequired;
indicator.CalculateOnBarClose = CalculateOnBarClose;
#if NT7
indicator.ForceMaximumBarsLookBack256 = ForceMaximumBarsLookBack256;
indicator.MaximumBarsLookBack = MaximumBarsLookBack;
#endif
indicator.Input = input;
Indicators.Add(indicator);
indicator.SetUp();
CB_NTCompileScript[] tmp = new CB_NTCompileScript[cacheCB_NTCompileScript == null ? 1 : cacheCB_NTCompileScript.Length + 1]; // <-- Anpassen
if (cacheCB_NTCompileScript != null) // <-- Anpassen
 cacheCB_NTCompileScript.CopyTo(tmp, 0); // <-- Anpassen
tmp[tmp.Length - 1] = indicator;
cacheCB_NTCompileScript = tmp; // <-- Anpassen
return indicator;
}
}
}
}
namespace NinjaTrader.MarketAnalyzer
{
public partial class Column : ColumnBase
{
[Gui.Design.WizardCondition("Indicator")]
public Indicator.CB_NTCompileScript CB_NTCompileScript() // <-- Anpassen - alle Parameter; kopmmagetrennt; keine lokalen Variablen
{
return _indicator.CB_NTCompileScript(Input); // <-- Anpassen - alle Parameter; kommagetrennt; keine lokalen Variablen
}
public Indicator.CB_NTCompileScript CB_NTCompileScript(Data.IDataSeries input) // <-- Anpassen - alle Parameter; kopmmagetrennt; keine lokalen Variablen
{
return _indicator.CB_NTCompileScript(input); // <-- Anpassen - alle Parameter; kopmmagetrennt; keine lokalen Variablen
}
}
}
namespace NinjaTrader.Strategy
{
public partial class Strategy : StrategyBase
{
[Gui.Design.WizardCondition("Indicator")]
public Indicator.CB_NTCompileScript CB_NTCompileScript() // <-- Anpassen - alle Parameter; kopmmagetrennt; keine lokalen Variablen
{
return _indicator.CB_NTCompileScript(Input); // <-- Anpassen - alle Parameter; kopmmagetrennt; keine lokalen Variablen
}
public Indicator.CB_NTCompileScript CB_NTCompileScript(Data.IDataSeries input) // <-- Anpassen - alle Parameter; kopmmagetrennt; keine lokalen Variablen
{
if (InInitialize && input == null)
throw new ArgumentException("You only can access an indicator with the default input/bar series from within the 'Initialize()' method");
return _indicator.CB_NTCompileScript(input);// <-- Anpassen - alle Parameter; kopmmagetrennt; keine lokalen Variablen
}
}
}
#endregion

 

Hier sieht man auch gleich den zweiten Punkt, den ich anmerken will:

VS kümmert sich nicht um den Code, den der NinjaEditor einfügt, und der "unter KEINEN Umständen" :-D geändert werden darf.

Benutzt man VS, muß man den Code nämlich definitiv ändern, und zwar, wenn man entweder den Namen der Klasse ändert, oder weitere Parameter hinzufügt.

Hier noch einmal der Code, den man nicht ändern darf, aber evtl. ändern muß :-D (alles im Code reinkommentiert):

#region NinjaScript generated code
namespace NinjaTrader.Indicator
{
public partial class Indicator : IndicatorBase
{
private CB_DefaultTemplate[] cacheCB_DefaultTemplate = null; // <-- Anpassen
private static CB_DefaultTemplate checkCB_DefaultTemplate = new CB_DefaultTemplate(); // <-- Anpassen
public CB_DefaultTemplate CB_DefaultTemplate(int parameter0) // <-- Anpassen - alle Parameter; kommagetrennt; keine lokalen Variablen
{
return CB_DefaultTemplate(Input, parameter0); // <-- Anpassen - alle Parameter; kommagetrennt; keine lokalen Variablen
}
public CB_DefaultTemplate CB_DefaultTemplate(Data.IDataSeries input, int parameter0) // <-- Anpassen - alle Parameter; kommagetrennt; keine lokalen Variablen
{
if (cacheCB_DefaultTemplate != null) // <-- Anpassen
for (int idx = 0; idx < cacheCB_DefaultTemplate.Length; idx++) // <-- Anpassen
 if (cacheCB_DefaultTemplate[idx].Parameter0 == parameter0 /*&&*/ && cacheCB_DefaultTemplate[idx].EqualsInput(input)) // <-- Anpassen - alle Parameter; &&-getrennt; keine lokalen Variablen
 return cacheCB_DefaultTemplate[idx]; // <-- Anpassen
lock (checkCB_DefaultTemplate) // <-- Anpassen
{
checkCB_DefaultTemplate.Parameter0 = parameter0; // <-- Anpassen
parameter0 = checkCB_DefaultTemplate.Parameter0; // <-- Anpassen
// Alle Parameter; keine lokalen Variablen
if (cacheCB_DefaultTemplate != null) // <-- Anpassen
 for (int idx = 0; idx < cacheCB_DefaultTemplate.Length; idx++) // <-- Anpassen
 if (cacheCB_DefaultTemplate[idx].Parameter0 == parameter0 /*&&*/ && cacheCB_DefaultTemplate[idx].EqualsInput(input)) // <-- Anpassen - alle Parameter; &&-getrennt; keine lokalen Variablen
 return cacheCB_DefaultTemplate[idx]; // <-- Anpassen
CB_DefaultTemplate indicator = new CB_DefaultTemplate(); // <-- Anpassen
indicator.BarsRequired = BarsRequired;
indicator.CalculateOnBarClose = CalculateOnBarClose;
#if NT7
indicator.ForceMaximumBarsLookBack256 = ForceMaximumBarsLookBack256;
indicator.MaximumBarsLookBack = MaximumBarsLookBack;
#endif
indicator.Input = input;
indicator.Parameter0 = parameter0; // <-- Anpassen
// Alle Parameter; keine lokalen Variablen
Indicators.Add(indicator);
indicator.SetUp();
CB_DefaultTemplate[] tmp = new CB_DefaultTemplate[cacheCB_DefaultTemplate == null ? 1 : cacheCB_DefaultTemplate.Length + 1]; // <-- Anpassen
if (cacheCB_DefaultTemplate != null) // <-- Anpassen
 cacheCB_DefaultTemplate.CopyTo(tmp, 0); // <-- Anpassen
tmp[tmp.Length - 1] = indicator;
cacheCB_DefaultTemplate = tmp; // <-- Anpassen
return indicator;
}
}
}
}
namespace NinjaTrader.MarketAnalyzer
{
public partial class Column : ColumnBase
{
[Gui.Design.WizardCondition("Indicator")]
public Indicator.CB_DefaultTemplate CB_DefaultTemplate(int parameter0) // <-- Anpassen - alle Parameter; kopmmagetrennt; keine lokalen Variablen
{
return _indicator.CB_DefaultTemplate(Input, parameter0); // <-- Anpassen - alle Parameter; kommagetrennt; keine lokalen Variablen
}
public Indicator.CB_DefaultTemplate CB_DefaultTemplate(Data.IDataSeries input, int parameter0) // <-- Anpassen - alle Parameter; kopmmagetrennt; keine lokalen Variablen
{
return _indicator.CB_DefaultTemplate(input, parameter0); // <-- Anpassen - alle Parameter; kopmmagetrennt; keine lokalen Variablen
}
}
}
namespace NinjaTrader.Strategy
{
public partial class Strategy : StrategyBase
{
[Gui.Design.WizardCondition("Indicator")]
public Indicator.CB_DefaultTemplate CB_DefaultTemplate(int parameter0) // <-- Anpassen - alle Parameter; kopmmagetrennt; keine lokalen Variablen
{
return _indicator.CB_DefaultTemplate(Input, parameter0); // <-- Anpassen - alle Parameter; kopmmagetrennt; keine lokalen Variablen
}
public Indicator.CB_DefaultTemplate CB_DefaultTemplate(Data.IDataSeries input, int parameter0) // <-- Anpassen - alle Parameter; kopmmagetrennt; keine lokalen Variablen
{
if (InInitialize && input == null)
throw new ArgumentException("You only can access an indicator with the default input/bar series from within the 'Initialize()' method");
return _indicator.CB_DefaultTemplate(input, parameter0);// <-- Anpassen - alle Parameter; kopmmagetrennt; keine lokalen Variablen
}
}
}
#endregion

 

So klappt's bei mir (bisher) einwandfrei...

Hi,

 

wenn du deine Klasse umbennest würde ich den Code unterhalb von "#region NinjaScript generated code " einfach komplett löschen und in NT neu compilieren - dann erstellt NT den ganzen Code passend zum neuen Klassenname. Es verhält sich also wie wenn du einen neuen Indikator oder Strategy erstellst, da ist der Code vor dem ersten compilieren auch noch nicht vorhanden.

 

Gruss,

askerix

wenn du deine Klasse umbennest würde ich den Code unterhalb von "#region NinjaScript generated code " einfach komplett löschen und in NT neu compilieren - dann erstellt NT den ganzen Code passend zum neuen Klassenname. Es verhält sich also wie wenn du einen neuen Indikator oder Strategy erstellst, da ist der Code vor dem ersten compilieren auch noch nicht vorhanden.

 

Hi,

Ich hab das gerade mal versucht.

 

Vorab noch kurz: Ich kenne mich mit NinjaTrader noch nicht wirklich gut aus. Und auch NinjaScript/C# lerne ich erst seit ein paar Monaten. Sprich, ich bin blutiger Ninja-Anfänger und hoffe auf Nachsicht, sollte ich jetzt hier totalen Blödsinn schreiben.

 

Du hast recht, wenn man mit dem NinjaEditor (NE) compiliert und vorher den NinjaScript generated code löscht, dann erstellt der NE diesen neu mit geändertem, passendem Klassennamen.

 

Selbst hinzugefügte Parameter/Inputs werden aber bei diesem Vorgehen nicht vom NE zum "NS generated code" hinzugefügt. Ehrlich gesagt bin ich mir auch garnicht sicher, was es bedeutet, wenn die da mit drin sind oder nicht !?! (evtl. kann das kurz jemand hier schildern...)

 

Meine Beobachtung war:

Ich hab einen Indikator ohne Input Parameter, einem mit einem Input Parameter und einen mit vier Input Parametern von NinjaTrader generieren lassen, und mir dann die Unterschiede im "NS generated code" angeschaut. So sieht man, daß dieser Codeabschnitt fast gleich ist, eben bis auf die Klassennamen und die Parameter (eben alles, was ich oben dort reinkommentiert habe).

 

Wenn man jetzt einen Input Parameter einfach per Code hinzufügt, dann ändert aber der NE diesen Abschnitt im "NS generated code" NICHT; daher mein manuelles Vorgehen. Was es bringt, oder welche Fehlverhalten dieser Codeabschnitt jetzt genau macht, kann ich nicht sagen; dafür bin ich zu grün. Aber, wenn's der NinjaEditor beim generieren so macht, will ich auch die weiteren hinzugefügten Input Parametern dort im Abschnitt stehen haben.

 

 

Falls mich jemand verstanden hat, soll er "Hier, Ich" schreiben :-D ... aber ich konnte mich nicht verständlicher ausdrücken.

Hier ich!!!

 

Willst du Parameter einfügen, so musst du diese sowohl in der #region Variables deklarieren, als auch in der #region Properties angeben.

...
 #region Variables
 private int period = 20;
...
 #region Properties
...

 [Description("")]
 [Category("Parameters")]
 public int Period
 {
	 get { return period; }
	 set { period = Math.Max(1, value); }
 }

Das reicht dem NT-Compiler.

Eins wäre noch zu beachten. Willst du über eine Member-Funktion auf Informationen aus diesem Indikator aus einem anderen Indikator oder einer Strategie zugreifen, so ist die Reihenfolge, mit der die Parameter definiert sind, nicht zwingend auch die Reihenfolge, die du als Funktionsparameter angeben musst.

Beispiel:

Du hast einen Indikator "Indi1" mit 2 Parametern

"Par1"

"Par2"

und einer MemberFunktion "GetInfo",

dann ist der Aufruf von GetInfo aus einem anderen Indikator nicht zwingend Indi1.GetInfo(Par1, Par2) sondern die Parameter können auch in einer anderen Reihenfolge nötig sein.

Wie genau findest du in dem NT-generierten Bereich.

Das aber nur am Rande.

Das aber nur am Rande.

 

Wenigstens ein Satz in dem Post, den Vola auch verstanden hat

 

Ha, 6 Posts in Folge, ohne das Licens dazwischen gefunkt hat !

(Der schläft bestimmt noch)

Eins wäre noch zu beachten. Willst du über eine Member-Funktion auf Informationen aus diesem Indikator aus einem anderen Indikator oder einer Strategie zugreifen, so ist die Reihenfolge, mit der die Parameter definiert sind, nicht zwingend auch die Reihenfolge, die du als Funktionsparameter angeben musst.

Beispiel:

Du hast einen Indikator "Indi1" mit 2 Parametern

"Par1"

"Par2"

und einer MemberFunktion "GetInfo",

dann ist der Aufruf von GetInfo aus einem anderen Indikator nicht zwingend Indi1.GetInfo(Par1, Par2) sondern die Parameter können auch in einer anderen Reihenfolge nötig sein.

Wie genau findest du in dem NT-generierten Bereich.

 

OK, verstehe...

Das bedeutet also, daß diese Parameter im NT-generierten Bereich drin sein sollten/müssen, um den Zugriff von ausserhalb zu ermöglichen??

 

 

Wenn man mit VS codet und NinjaEditor nur zum compilen benutzt, sollte man also deswegen ein Auge drauf haben, ob da (im NT-generierten Code) auch alles richtig drinsteht. Weil, wie gesagt, wenn ich einem Indikator weitere Parameter dazucode, werden die dem NT-gen. Bereich nicht hinzugefügt.

 

 

Danke, WOGO !!

Jetzt weiß ich nen ganzen Schwung mehr, als heute Morgen :-D

Das bedeutet also, daß diese Parameter im NT-generierten Bereich drin sein sollten/müssen, um den Zugriff von ausserhalb zu ermöglichen??

Jein

Wenn du die Parameter so einträgst, wie oben beschrieben, dann macht NT die auch richtig in den NT-generierten Teil rein.

Allerdings nicht unbeding in der Reihenfolge, in der du sie angegeben hast.

 

Ich such heute Abend mal ein Beispiel raus.

Ich such heute Abend mal ein Beispiel raus.

Also... ich bin jetzt auch kein C#-Experte, darum hier die Erklärung anhand eines Beispiels, so wie ich es verstehe..

 

Wir haben einen Indikator.

Die eigentliche Funktionalität wird in eine neue Klasse mit dem Indikatornamen (von uns) codiert. Hier sind auch die Parameter.

namespace NinjaTrader.Indicator
{
public class wgLRMAColorTrend : Indicator
{
 #region Variables
 private int period = 21;				 // Parameter 1
 private double extTrendDiff = 1; //Parameter 2

In diese Klasse kommen auch die Parametereigenschaften

...
 #region Properties
 [Description("MA-Period")]
 [GridCategory("Parameters")]
 public int Period
 {
	 get { return period; }
	 set { period = Math.Max(1, value); }
 }
 [Description("Trend Differenz in Punkten, ab der der Trend von neutral aus auf/ab schalten kann")]
 [GridCategory("Parameters")]
 public double ExtTrendDiff
 {
	 get { return extTrenddiff; }
	 set { extTrendDiff = Math.Max(0, value); }
 }
 #endregion

Über die GridCategory weiss NT, dass es sich um einen Parameter handelt (Vermutung von mir).

 

In die Klasse Indikator, die das Schlüsselwort partial vorangestellt hat - d.h., dass sie über verschiedene Module verteilt implementiert ist - wird nun ein Objekt-Array

vom Typ unserer Klasse erzeugt (autmatisch von NT vor dem Compilieren).

public partial class Indicator : IndicatorBase
{
 private wgLRMAColorTrend[] cachewgLRMAColorTrend = null;
 ...

Hier erzeugt NT auch die Zugriffsfunktion, die aufgerufen wird, wenn man den Indikator aus einer Strategie oder einem anderen Indikator aus aufruft:

 public wgLRMAColorTrend wgLRMAColorTrend(double extTrendDiff, int period)
 {
	 return wgLRMAColorTrend(Input, extTrendDiff, period);
 }

 /// <summary>
 /// Draws a minimum-gap MA with 3 different colors. Red: Down-trend Yellow: No-trend Green: Up-Trend
 /// </summary>
 /// <returns></returns>
 public wgLRMAColorTrend wgLRMAColorTrend(Data.IDataSeries input, double extTrendDiff, int period)
 {
...

... innerhalb der wieder eine Instanz unseres Indikators erzeugt wird und die Parameter an die Membervariablen der Indikatorklasse zugewiesen werden:

		 wgLRMAColorTrend indicator = new wgLRMAColorTrend();
		 indicator.BarsRequired = BarsRequired;
		 indicator.CalculateOnBarClose = CalculateOnBarClose;
#if NT7
		 indicator.ForceMaximumBarsLookBack256 = ForceMaximumBarsLookBack256;
		 indicator.MaximumBarsLookBack = MaximumBarsLookBack;
#endif
		 indicator.Input = input;
		 indicator.ExtTrendDiff = extTrendDiff;
		 indicator.Period = period;

 

Dies funktioniert allerdings nur richtig, wenn man beim Aufruf des Indikators aus dem anderen Indikator oder der Strategie heraus auch die richtige Reihenfolge der Parameter angibt.

 

Die meisten denken sich jetzt, warum schreibt der eigentlich dieses wirre Zeug, interessiert doch eh keinen!

 

Tja, weil ich kürzlich eine Woche lang gesucht habe, warum ein Indikator nichts anzeigt, obwohl alles (vermeintlich) richtig programmiert ist.

War es halt nicht. Ich hatte die Parameter in der Reihenfolge in der sie deklariert sind übergeben und das war halt (in diesem Fall) falsch.

Also... ich bin jetzt auch kein C#-Experte, darum hier die Erklärung anhand eines Beispiels, so wie ich es verstehe...

...
 #region Properties
 [Description("MA-Period")]
 [GridCategory("Parameters")]
 public int Period
 {
	 get { return period; }
	 set { period = Math.Max(1, value); }
 }
 [Description("Trend Differenz in Punkten, ab der der Trend von neutral aus auf/ab schalten kann")]
 [GridCategory("Parameters")]
 public double ExtTrendDiff
 {
	 get { return extTrenddiff; }
	 set { extTrendDiff = Math.Max(0, value); }
 }
 #endregion

Über die GridCategory weiss NT, dass es sich um einen Parameter handelt (Vermutung von mir)...

 

Dies funktioniert allerdings nur richtig, wenn man beim Aufruf des Indikators aus dem anderen Indikator oder der Strategie heraus auch die richtige Reihenfolge der Parameter angibt. Die meisten denken sich jetzt, warum schreibt der eigentlich dieses wirre Zeug, interessiert doch eh keinen! Tja, weil ich kürzlich eine Woche lang gesucht habe, warum ein Indikator nichts anzeigt, obwohl alles (vermeintlich) richtig programmiert ist. War es halt nicht. Ich hatte die Parameter in der Reihenfolge in der sie deklariert sind übergeben und das war halt (in diesem Fall) falsch.

 

Super Erklärung !!

 

Jetzt hab ich den Sinn dieses Ninja generated code einiger maßen kapiert.

Ich werde dein Posting aber morgen nochmal in Begleitung meines C#-Buches durchgehen, um die restlichen Klarheiten zu beseitigen :-D

 

Das mit der GridCategory ist nicht ganz korrekt; Ninja erkennt Parameter einfach daran, daß sie public [type] [name] { get..; set...; } sind. Wenn man nämlich das GridCategory wegläßt/auskommentiert, dann kann man den Indikator weiterhin über z.b. _FiboRT(0, 100, False) von ausserhalb berechnen, aber bei den IndikatorEigenschaften (also, wenn man ihn einfach auf einen Chart lädt) werden diese Parameter nicht mehr angezeigt.

 

Nützlich war das z.B. bei eben diesem selbstgebauten _FiboRT-Indikator, der einerseits auf einen Chart angewendet automatisch die Fibos des Vortages anzeigen soll, andererseits aber über z.B. eine Strategie aufgerufen eine über die Parameter definierbare Spanne berechnen kann.

Zur Info:

 

Das sind Auto Implemented Properties - http://msdn.microsof...y/bb384054.aspx.

Sie sollen bzw. machen das Erstellen von Indikatoren leichter. Ein Ansatz der OO. Get oder Set

können weggelassen werden. So kann man lesende und schreibende Zugriffe definieren.