/// <summary>
/// Création d'un fichier manifest à partir d'un type
/// </summary>
/// <param name="strategyType">Type of the strategy.</param>
/// <returns></returns>
public static string CreateManifest(Type strategyType)
{
StrategyManifest m = new StrategyManifest();
StrategyBase strategy = (StrategyBase)Activator.CreateInstance(strategyType ?? typeof(GenericStrategy));
StringBuilder sb = new StringBuilder();
using (StringWriter ms = new StringWriter(sb))
{
XmlSerializer serializer = new XmlSerializer(typeof(StrategyBase), new Type[] { strategyType });
serializer.Serialize(ms, strategy);
// On met le résultat dans le noeud dédié
XmlDocument xdoc = new XmlDocument();
xdoc.LoadXml(sb.ToString().Substring(39));
m.StrategyConfiguration = xdoc.FirstChild;
}
if (strategyType != null)
{
m.StrategyTypeName =
String.Format("{0},{1}", strategyType.FullName, strategyType.Assembly.GetName().Name);
}
sb = new StringBuilder();
using (StringWriter w = new StringWriter(sb))
{
// Désérialization de la description
XmlSerializer serializer = new XmlSerializer(typeof(StrategyManifest));
serializer.Serialize(w, m);
}
return(sb.ToString());
}
/// <summary>
/// Instancie le manifest
/// </summary>
/// <param name="manifestFileName">Name of the manifest file.</param>
/// <returns></returns>
internal static StrategyManifest DeserializeManifest(string manifestFileName)
{
using (StreamReader reader = new StreamReader(manifestFileName))
{
// Désérialization de la description
XmlSerializer serializer = new XmlSerializer(typeof(StrategyManifest));
StrategyManifest manifest = (StrategyManifest)serializer.Deserialize(reader);
return(manifest);
}
}
/// <summary>
/// Adds the strategies.
/// </summary>
/// <param name="results">The results.</param>
/// <param name="node">The node.</param>
private static void AddStrategies(ManifestCollection results, object node)
{
if (node != null)
{
Debug.Assert(node is NodeData);
StrategyManifest manifest = ((NodeData)node).Value as StrategyManifest;
if (manifest != null && !results.Contains(manifest))
{
results.Add(manifest);
}
}
}
/// <summary>
/// Création de l'instance de la strategie contenu dans le manifest
/// </summary>
/// <param name="owner"></param>
/// <param name="manifest">Manifest contenant la stratégie</param>
/// <returns></returns>
public StrategyBase AddStrategy(CandleElement owner, StrategyManifest manifest)
{
InternalPackage package = GetPackage(manifest.PackageName);
if (package == null)
{
return(null);
}
StrategyBase strategy = package.CreateStrategyInstance(manifest.StrategyTypeName, manifest.StrategyConfiguration);
if (strategy != null)
{
strategy.Owner = GetStrategyOwnerName(owner);
// Vérification des doublons
foreach (StrategyBase other in _strategies)
{
if (other.Owner == strategy.Owner && other.StrategyId == strategy.StrategyId)
{
return(other);
}
}
try
{
strategy.OnLoading(this, new EventArgs());
_strategies.Add(strategy);
}
catch (Exception ex)
{
IIDEHelper ide = ServiceLocator.Instance.GetService <IIDEHelper>();
if (ide != null)
{
ide.ShowMessageBox("Error when loading strategy " + strategy.DisplayName + " : " + ex.Message, "Error", System.Windows.Forms.MessageBoxButtons.OK);
ide.LogError(false, "Error when loading strategy " + strategy.DisplayName + " : " + ex.Message, 0, 0, "StrategyManager");
}
}
}
return(strategy);
}
/// <summary>
/// recherche des fichiers manifests
/// </summary>
/// <param name="folder">The folder.</param>
private void FindManifests(string folder)
{
Debug.Assert(_manifests != null);
foreach (string manifestFileName in Utils.SearchFile(folder, "*.manifest"))
{
try
{
StrategyManifest sm = StrategyManifest.DeserializeManifest(manifestFileName);
sm.PackageName = _name;
sm.FileName = manifestFileName;
_manifests.Add(sm);
}
catch (Exception ex)
{
ILogger logger = ServiceLocator.Instance.GetService <ILogger>();
if (logger != null)
{
logger.WriteError("Strategy package",
String.Format("Error when reading the manifest file {0}", manifestFileName),
ex);
}
}
}
}
