public SeasonSimulationResult PerformSimulation(IStrategy strategy, SeasonSimulationOptions options)
        {
            if (strategy == null) throw new ArgumentNullException("strategy");

            var allPlayers = GetPlayersForFirstGameweek();

            var maxGameweek = CalculateMaxGameweek(options.MaximumGameweek);

            _logger.Log(Tag.Simulation, string.Concat("Max gameweek is ", maxGameweek));

            var startingTeam = options.UseSavedInitialTeam ? SelectInitialTeamByIds(allPlayers, options.InitialTeamPlayerIds) : strategy.PickStartingTeam(allPlayers);

            _logger.Log(Tag.Simulation, "Starting team picked");
            LogHelper.LogTeam(startingTeam, _logger);

            if (options.ChooseInitialTeamOnly)
            {
                return new SeasonSimulationResult();
            }

            var seasonState = _decisionActioner.ValidateAndApplyStartingTeam(startingTeam, allPlayers);

            _logger.Log(Tag.Simulation, "Applied starting team");

            return SimulateSeason(seasonState, strategy, maxGameweek);
        }

 public QuoteProvider(IStrategy owner)
 {
     _owner = owner;
     _lastPeek = new DateTime(1900, 1, 1);
     _timer = new Timer(1000);
     _timer.Elapsed += new ElapsedEventHandler(OnTick);
 }

        public void run()
        {
            try
            {
                remoteProcessClient.WriteToken(token);
                int teamSize = remoteProcessClient.ReadTeamSize();
                remoteProcessClient.WriteProtocolVersion();
                Game game = remoteProcessClient.readGameContext();

                IStrategy[] strategies = new IStrategy[teamSize];

                for (int strategyIndex = 0; strategyIndex < teamSize; ++strategyIndex)
                {
                    strategies[strategyIndex] = new MyStrategy();
                }

                PlayerContext playerContext;

                while ((playerContext = remoteProcessClient.ReadPlayerContext()) != null)
                {
                    Trooper playerTrooper = playerContext.Trooper;

                    Move move = new Move();
                    strategies[playerTrooper.TeammateIndex].Move(playerTrooper, playerContext.World, game, move);
                    remoteProcessClient.WriteMove(move);
                }
            }
            finally
            {
                remoteProcessClient.Close();
            }
        }

 /// <summary>
 /// 增加一个策略,和关注的股票价格
 /// </summary>
 /// <param name="code">股票代码</param>
 /// <param name="strategy">策略实例</param>
 public void AddStock(String code, IStrategy strategy)
 {
     if (stockDataCache[code] == null)
     {
         stockDataCache[code] = new StockDataQueue();
     }
     stockDataCache[code].OnStockDataChange += strategy.OnStockDataChanged;
 }

 public Template(IStrategy strategy, String templateText, String[] namespaces,
                 params Variable[] variables)
 {
     _strategy = strategy;
     this.templateText = templateText;
     this.namespaces = namespaces;
     this.variables = variables;
 }

        public StrategyControl(IStrategy strategy)
        {
            InitializeComponent();
            this.strategy = strategy;

            // load my stock pool
            LoadMyStockPool();
        }

        public ConfigurationContext BuildConfigurationContext(BaseFeature feature, IStrategy strategy)
        {
            if (string.IsNullOrWhiteSpace(Key))
            {
                throw new ArgumentException("Missing 'Key' parameter for '" + strategy.GetType().Name + "' strategy for '" + feature.Name + "' feature");
            }

            return new ConfigurationContext(this);
        }

 public ComplexStrategy(IStrategy[] innerStrategies, string name, long quantity,
                        IStrategy defaultStrategy, StrategyType strategyType)
 {
     _innerStrategies = innerStrategies;
     _name = name;
     _quantity = quantity;
     _defaultStrategy = defaultStrategy;
     _strategyType = strategyType;
 }

 public GuardianAgentSession(Agent agent, string process,
     IStrategy redStrategy, IStrategy yellowStrategy, double e1, double e2)
 {
     this.Agent = agent;
     this.TargetProcess = process;
     this.RedStrategy = redStrategy;
     this.YellowStrategy = yellowStrategy;
     this.E1 = e1;
     this.E2 = e2;
 }

 public ReachabilityStrategyCalculationAlgorithm(ITestGraph testGraph, IStrategy strategy)
 {
     if (this.testGraph == null)
     {
         throw new ArgumentNullException("testGraph");
     }
     this.testGraph = testGraph;
     this.strategy = new QuickGraph.Algorithms.TestGames.Strategy();
     this.performanceComparer = new PairPreOrderPerformanceComparer();
 }

        public FoxWatchMainController(IStrategy strategy, DBOutEnum dbOutEnum)
        {
            _strategy = strategy;

            Boolean bDBOut_InRunning = false;
            if (dbOutEnum == DBOutEnum.Enable)
            {
                bDBOut_InRunning = true;
            }
            _foxCaptureController = new FoxWatchCaptureController(bDBOut_InRunning);
        }

 public RecognizedAgent(string name, double res,
     IStrategy redStrategy, IStrategy yellowStrategy,
     double p1, double p2)
 {
     Name = name;
     m_P1 = p1;
     m_P2 = p2;
     m_Res = res;
     m_RedStrategy = redStrategy;
     m_YellowStrategy = yellowStrategy;
 }

 /// <summary>
 /// 在行情市场中登记一个策略，当关注股票价格发生变动的时候，即时提醒策略。
 /// </summary>
 /// <param name="strategy">策略实例</param>
 public void RegisterStrategy(IStrategy strategy)
 {
     foreach (string code in strategy.StockPool)
     {
         if (!StockMarketManager.bidCache.ContainsKey(code))
         {
             StockMarketManager.bidCache.Add(code, new BidCacheQueue());
         }
         StockMarketManager.bidCache[code].OnBidChange += strategy.OnStockDataChanged;
     }
 }

        private void ProcessStrategy(IStrategy strategy)
        {
            foreach (var quote in this.quotes)
            {
                strategy.ProcessQuote(quote);
            }

            if (Interlocked.Decrement(ref numberOfTasks) == 0)
            {
                signal.Set();
            }
        }

 public BackTest(
     IEventBus eventBus,
     IDataHandler bars, 
     IStrategy strategy, 
     IPortfolio portfolio, 
     IExecutionHandler executionHandler)
 {
     this.eventBus = eventBus;
     this.bars = bars;
     this.strategy = strategy;
     this.portfolio = portfolio;
     this.executionHandler = executionHandler;
     this.stopWatch = new Stopwatch();
 }

        public static void Main(string[] args)
        {
            // Some pre-processing filters.
            IFilter[] filters = new IFilter[] {
                new BMPConvert(),
                // new DynamicRangeReduce(),
            };

            // Find all strategies and instantiate.
            Type[] strategy_types = Assembly
                .GetExecutingAssembly()
                .GetTypes()
                .Where(
                    type => typeof(IStrategy).IsAssignableFrom(type) && typeof(IStrategy) != type
                )
                .ToArray();

            IStrategy[] strategies = new IStrategy[strategy_types.Length];
            for(int t = 0; t < strategy_types.Length; ++t) {
                strategies[t] = (IStrategy) Activator.CreateInstance(strategy_types[t]);
            }

            StringBuilder html = new StringBuilder();
            html.Append ("<html><body>");
            foreach(string arg in args) {

                // Load image from arguments.
                Image bmp = Image.FromFile(arg);

                // Run through filters.
                foreach(IFilter filter in filters) {
                    bmp = filter.filter (bmp);
                }

                // Run through each strategy.
                html.AppendFormat ("<div><h2>{0}</h2>", arg);
                foreach(IStrategy strategy in strategies) {
                    String table = GenerateHTMLForImage(bmp, strategy);

                    html.AppendFormat ("<h3>{0}</h3><p>{1} bytes</p><div>{2}</div>", strategy.Name, table.Length, table);

                }
                html.Append ("</div>");

            }
            html.Append ("</body>");

            // Dump to console.
            Console.Write (html.ToString ());
        }

        private static String GenerateHTMLForImage(Image img, IStrategy strategy)
        {
            // Create table .
            Table tbl = new Table();

            // Convert image.
            strategy.generateTable(img, tbl);

            // Table to HTML.
            HTMLBuilder builder = new HTMLBuilder();
            tbl.accept(builder);

            return builder.HTML;
        }

        public void run()
        {
            try
            {
                remoteProcessClient.WriteToken(token);
                int teamSize = remoteProcessClient.ReadTeamSize();

                IStrategy[] strategies = new IStrategy[teamSize];
                TankType[] tankTypes = new TankType[teamSize];

                for (int strategyIndex = 0; strategyIndex < teamSize; ++strategyIndex)
                {
                    IStrategy strategy = new MyStrategy();
                    strategies[strategyIndex] = strategy;
                    tankTypes[strategyIndex] = strategy.SelectTank(strategyIndex, teamSize);
                }

                remoteProcessClient.WriteSelectedTanks(tankTypes);

                PlayerContext playerContext;

                while ((playerContext = remoteProcessClient.ReadPlayerContext()) != null)
                {
                    Tank[] playerTanks = playerContext.Tanks;
                    if (playerTanks.Length != teamSize)
                    {
                        break;
                    }

                    Move[] moves = new Move[teamSize];

                    for (int strategyIndex = 0; strategyIndex < teamSize; ++strategyIndex)
                    {
                        Move move = new Move();
                        moves[strategyIndex] = move;
                        strategies[strategyIndex].Move(playerTanks[strategyIndex], playerContext.World, move);
                    }

                    remoteProcessClient.WriteMoves(moves);
                }
            }
            finally
            {
                remoteProcessClient.Close();
            }
        }

        public Agent(IStrategy strategy, List<Account> accounts)
        {
            this._strategy = strategy;
            _accounts = accounts;

            _bStart = false;

            AgentManager.Ins().Register(this);
            ScheduleManager.Ins().AddSchedule(this);

            foreach (Account account in accounts)
            {
                account.SetAgent(this);
            }

            this._strategy.TakeOverRemainPosition();
        }

 // Changing strategies
 public void SwitchStrategy()
 {
     if (strategy is Strategy1)
         strategy = new Strategy2();
     else
         strategy = new Strategy1();
 }