/// <summary>
/// Engine calls this method to tell this type that it has loaded this type.
/// The type should hook up to EngineCleanup event so that when that event is called, this type can flush all resources it has cached.
/// Engine raises this event when it has finished a session run.
/// </summary>
/// <param name="host">Host, whose EngineCleanup event which we should handle when this type should reinitialize</param>
public static void EngineCleanupHandler(ResourceStaticAnalysisEngine host)
{
//Implementation of ClassificationObject should provide its own override for this method (using 'new' keyword)
//if it contains static resources that grow over time. This way the engine has a way to tell this implementation to free its resources
//when the engine reinitializes.
//You can do it by adding a hander such as the following:
//engineCleanupAction += MyCleanupMethod;
//And reset your static resources to initial state.
}
/// <summary>
/// Creates an instance of EngineMonitor for the given engine.
/// </summary>
/// <param name="engine">ResourceStaticAnalysisEngine object to be monitored</param>
internal EngineMonitor(ResourceStaticAnalysisEngine engine)
{
this._engine = engine;
LogExceptionDetails = false;
Reset();
#region Registering for engine events
engine.LoadingStarting += (s, e) => loadingStart = DateTime.Now;
engine.LoadingFinished += (s, countArgs) => { loadingEnd = DateTime.Now; objectsLoaded = countArgs.Value; };
engine.ProcessingStarting += (s, e) => processingStart = DateTime.Now;
engine.ProcessingFinished += (s, e) => processingEnd = DateTime.Now;
engine.OutputStarting += (s, e) => outputStart = DateTime.Now;
engine.OutputFinished += (s, e) => outputEnd = DateTime.Now;
engine.EngineCleanup += (s, e) => this.Reset();
#endregion
}
/// <summary>
/// Make sure to call base implementation first, as it may perform some cleanup for the base class.
/// ResourceStaticAnalysis calls this method once
/// for each type when the first instance of the type is loaded. In this method
/// you can register any cleanup code you want to run with the ResourceStaticAnalysis.EngineCleanup event.
/// This cleanup code IS NOT for instances of Classification Objects but for the entire type - i.e.
/// if you have static fields that cache data you may want to register them for cleanup so in case engine
/// runs multiple times they can be reset between the multiple runs.
/// </summary>
/// <param name="engine">ResourceStaticAnalysis instance for which cleanup we want to listen.</param>
public virtual void RegisterTypeForEngineCleanup(ResourceStaticAnalysisEngine engine)
{
}