I've been programming in c#/.NET on Multicharts for a while. Once you start working with more complex, and larger datasets you can't really rely on the standard VariableSeries<> anymore. That type carries a value for every. single. bar.

So I started trying to be more efficient. I used the List<> type where I could insert values to keep the same [0] as most recent. You can also resize the list so it only carries relevant numbers of values and doesn't just continually expand. The results are pretty impressive, much faster load times for strategies, indicators, and the optimizer runs faster as well.

However, there's something I discovered that needs to be kept in mind:

When using things like lists or specifying doubles right under the public class level, MultiCharts .NET in general will pass previous values if you simply "recalculate" a study. For indicators it does this as well, you'll see it if you click click on the indicator title to "mute" it, then click it back on again. This issue persists into the optimizer as well. Whatever your previous parameter check had as values gets passed as the first values for the next iteration. That's a big problem because it starts showing results in the optimizer that are completely different even if you apply those specific parameters.

This appears to happen because MultiCharts .NET doesn't load the entire script each time it reloads. It fills in parameter values but then starts the reload process at the StartCalc override.

To solve this issue, you need to clear Lists or single declaration in the StartCalc override.

The end result looks something like this:

protected override void StartCalc(){

m_xaverage1.Price = Bars.Close;
m_xaverage1.Length = MacroTrendLength;
m_xaverage2.Price = Bars.Close;
m_xaverage2.Length = ShorterLengthAvg;

askEff.Clear();
bidAbsorbed.Clear();
bidEff.Clear();
askAbsorbed.Clear();

askEffAvg = 0;
bidAbsorbAvg = 0;
bidEffAvg = 0;
askAbsorbAvg = 0;
combineAsk.Value = 0;
combineBid.Value = 0;

}

Just putting this out there in case someone starts pulling their hair out with frustration because MC .NET isn't behaving the way it seems it should.

Just wondering. Have you reached out to the MultiCharts team and see what they say? Is it working as designed or a limitation in MC?

FYI. I have two licenses (MC + MC.NET) and have not used MC.NET much.

FuManChou 

Just wondering. Have you reached out to the MultiCharts team and see what they say? Is it working as designed or a limitation in MC?

@FuManChou,

I wondered that too. From what's documented in this thread and consistent with how MC.NET works under the hood, this is by design -- or at least a known behavior rather than a bug.

The key detail: MultiCharts .NET does not fully reload the script object between optimizer passes. It reuses the same instance, plugs in the new parameter values, and fires StartCalc again. Efficient from MC's perspective, but it means anything allocated at the class level -- your List collections, double accumulators, running totals -- carries over from the previous iteration.

VariableSeries resets cleanly because MC manages that lifecycle internally. Class-level variables are your responsibility.

The fix is to treat StartCalc as your full initialization point:

• Call .Clear() on every List (askEff, bidAbsorbed, etc.)
• Reset all class-level doubles and counters to zero
• Re-assign price series -- e.g. m_xaverage.Price = Bars.Close

Once you internalize that MC.NET optimizer passes share the same object instance, the behavior makes sense -- and the explicit reset in StartCalc becomes second nature.

Whether you call it a design decision or a design limitation probably depends on how many hours you spent debugging it first.

-- Fi

"Knowing what resets and what persists is the difference between a clean optimizer and a ghost in your data."